mom_forcing_type Module Reference

Detailed Description

This module implements boundary forcing for MOM6.

Boundary fluxes

The ocean is a forced-dissipative system. Forcing occurs at the boundaries, and this module mediates the various forcing terms from momentum, heat, salt, and mass. Boundary fluxes from other tracers are treated by coupling to biogeochemical models. We here present elements of how MOM6 assumes boundary fluxes are passed into the ocean.

Note that all fluxes are positive into the ocean. For surface boundary fluxes, that means fluxes are positive downward. For example, a positive shortwave flux warms the ocean.

Surface boundary momentum fluxes

The ocean surface exchanges momentum with the overlying atmosphere, sea ice, and land ice. The momentum is exchanged as a horizontal stress (Newtons per squared meter: N/m2) imposed on the upper ocean grid cell.

Surface boundary mass fluxes

The ocean gains or loses mass through evaporation, precipitation, sea ice melt/form, and and river runoff. Positive mass fluxes add mass to the liquid ocean. The boundary mass flux units are (kilogram per square meter per sec: kg/(m2/sec)).

• Evaporation field can in fact represent a mass loss (evaporation) or mass gain (condensation in foggy areas).
• sea ice formation leads to mass moving from the liquid ocean to the ice model, and melt adds liquid to the ocean.
• Precipitation can be liquid or frozen (snow). Furthermore, in some versions of the GFDL coupler, precipitation can be negative. The reason is that the ice model combines precipitation with ice melt and ice formation. This limitation of the ice model diagnostics should be overcome future versions.
• River runoff can be liquid or frozen. Frozen runoff is often associated with calving land-ice and/or ice bergs.

Surface boundary salt fluxes

Over most of the ocean, there is no exchange of salt with the atmosphere. However, the liquid ocean exchanges salt with sea ice. When ice forms, it extracts salt from ice pockets and discharges the salt into the liquid ocean. The salt concentration of sea ice is therefore much lower (around 5ppt) than liquid seawater (around 30-35ppt in high latitudes).

For ocean-ice models run with a prescribed atmosphere, such as in the CORE/OMMIP simulations, it is necessary to employ a surface restoring term to the k=1 salinity equation, thus imposing a salt flux onto the ocean even outside of sea ice regimes. This salt flux is non-physical, and represents a limitation of the ocean-ice models run without an interactive atmosphere. Sometimes this salt flux is converted to an implied fresh water flux. However, doing so generally leads to changes in the sea level, unless a global normalization is provided to zero-out the net water flux. As a complement, for models with a restoring salt flux, one may choose to zero-out the net salt entering the ocean. There are pros/cons of each approach.

Surface boundary heat fluxes

There are many terms that contribute to boundary-related heating of the k=1 surface model grid cell. We here outline details of this heat, with each term having units W/m2.

The net flux of heat crossing ocean surface is stored in the diagnostic array "hfds". This array is computed as

\[ \mbox{hfds = shortwave + longwave + latent + sensible + mass transfer + frazil + restore + flux adjustments} \]

• shortwave (SW) = shortwave radiation (always warms ocean)
• longwave (LW) = longwave radiation (generally cools ocean)
• latent (LAT) = turbulent latent heat loss due to evaporation (liquid to vapor) or melt (snow to liquid); generally cools the ocean
• sensible (SENS) = turbulent heat transfer due to differences in air-sea or ice-sea temperature
• mass transfer (MASS) = heat transfer due to heat content of mass (e.g., E-P+R) transferred across ocean surface; computed relative to 0 Celsius
• frazil (FRAZ) = heat transferred to form frazil sea ice (positive heating of liquid ocean)
• restore (RES) = heat from surface damping sometimes imposed in non-coupled model simulations .
• restore (flux adjustments) = heat from surface flux adjustment.

Treatment of shortwave

The shortwave field itself is split into two pieces:

• shortwave = penetrative SW + non-penetrative SW
• non-penetrative = non-downwelling shortwave; portion of SW totally absorbed in the k=1 cell. The non-penetrative SW is combined with LW+LAT+SENS+seaice_melt_heat in net_heat inside routine extractFluxes1d. Notably, for many cases, non-penetrative SW = 0.
• penetrative = that portion of shortwave penetrating below a tiny surface layer. This is the downwelling shortwave. Penetrative SW participates in the penetrative SW heating of k=1,nz cells, with the amount of penetration dependent on optical properties.

Convergence of heat into the k=1 cell

The convergence of boundary-related heat into surface grid cell is given by the difference in the net heat entering the top of the k=1 cell and the penetrative SW leaving the bottom of the cell.

\begin{eqnarray*} Q(k=1) &=& \mbox{hfds} - \mbox{pen_SW(leaving bottom of k=1)} \\ &=& \mbox{nonpen_SW} + (\mbox{pen_SW(enter k=1)}-\mbox{pen_SW(leave k=1)}) + \mbox{LW+LAT+SENS+MASS+FRAZ+RES} \\ &=& \mbox{nonpen_SW}+ \mbox{LW+LAT+SENS+MASS+FRAZ+RES} + [\mbox{pen_SW(enter k=1)} - \mbox{pen_SW(leave k=1)}] \end{eqnarray*}

The convergence of the penetrative shortwave flux is given by \( \mbox{pen_SW (enter k)}-\mbox{pen_SW (leave k)}\). This term appears for all cells k=1,nz. It is diagnosed as "rsdoabsorb" inside module MOM6/src/parameterizations/vertical/MOM_diabatic_aux.F90

Data Types
type	forcing
	Structure that contains pointers to the boundary forcing used to drive the liquid ocean simulated by MOM. More...
type	forcing_diags
	Structure that defines the id handles for the forcing type. More...
type	mech_forcing
	Structure that contains pointers to the mechanical forcing at the surface used to drive the liquid ocean simulated by MOM. Data in this type is allocated in the module MOM_surface_forcing.F90, of which there are three versions: solo, coupled, and ice-shelf. More...

Functions/Subroutines
subroutine, public	extractfluxes1d (G, GV, US, fluxes, optics, nsw, j, dt_in_T, FluxRescaleDepth, useRiverHeatContent, useCalvingHeatContent, h, T, netMassInOut, netMassOut, net_heat, net_salt, pen_SW_bnd, tv, aggregate_FW, nonpenSW, netmassInOut_rate, net_Heat_Rate, net_salt_rate, pen_sw_bnd_Rate, skip_diags)
	This subroutine extracts fluxes from the surface fluxes type. It works on a j-row for optimization purposes. The 2d (i,j) wrapper is the next subroutine below. This routine multiplies fluxes by dt, so that the result is an accumulation of fluxes over a time step. More...
subroutine, public	extractfluxes2d (G, GV, US, fluxes, optics, nsw, dt_in_T, FluxRescaleDepth, useRiverHeatContent, useCalvingHeatContent, h, T, netMassInOut, netMassOut, net_heat, Net_salt, Pen_SW_bnd, tv, aggregate_FW)
	2d wrapper for 1d extract fluxes from surface fluxes type. This subroutine extracts fluxes from the surface fluxes type. It multiplies the fluxes by dt, so that the result is an accumulation of the fluxes over a time step. More...
subroutine, public	calculatebuoyancyflux1d (G, GV, US, fluxes, optics, nsw, h, Temp, Salt, tv, j, buoyancyFlux, netHeatMinusSW, netSalt, skip_diags)
	This routine calculates surface buoyancy flux by adding up the heat, FW & salt fluxes. These are actual fluxes, with units of stuff per time. Setting dt=1 in the call to extractFluxes routine allows us to get "stuf per time" rather than the time integrated fluxes needed in other routines that call extractFluxes. More...
subroutine, public	calculatebuoyancyflux2d (G, GV, US, fluxes, optics, h, Temp, Salt, tv, buoyancyFlux, netHeatMinusSW, netSalt, skip_diags)
	Calculates surface buoyancy flux by adding up the heat, FW and salt fluxes, for 2d arrays. This is a wrapper for calculateBuoyancyFlux1d. More...
subroutine, public	mom_forcing_chksum (mesg, fluxes, G, US, haloshift)
	Write out chksums for thermodynamic fluxes. More...
subroutine, public	mom_mech_forcing_chksum (mesg, forces, G, US, haloshift)
	Write out chksums for the driving mechanical forces. More...
subroutine	mech_forcing_singlepointprint (forces, G, i, j, mesg)
	Write out values of the mechanical forcing arrays at the i,j location. This is a debugging tool. More...
subroutine, public	forcing_singlepointprint (fluxes, G, i, j, mesg)
	Write out values of the fluxes arrays at the i,j location. This is a debugging tool. More...
subroutine, public	register_forcing_type_diags (Time, diag, US, use_temperature, handles, use_berg_fluxes)
	Register members of the forcing type for diagnostics. More...
subroutine, public	forcing_accumulate (flux_tmp, forces, fluxes, G, wt2)
	Accumulate the forcing over time steps, taking input from a mechanical forcing type and a temporary forcing-flux type. More...
subroutine, public	fluxes_accumulate (flux_tmp, fluxes, G, wt2, forces)
	Accumulate the thermodynamic fluxes over time steps. More...
subroutine, public	copy_common_forcing_fields (forces, fluxes, G, skip_pres)
	This subroutine copies the computational domains of common forcing fields from a mech_forcing type to a (thermodynamic) forcing type. More...
subroutine, public	set_derived_forcing_fields (forces, fluxes, G, US, Rho0)
	This subroutine calculates certain derived forcing fields based on information from a mech_forcing type and stores them in a (thermodynamic) forcing type. More...
subroutine, public	set_net_mass_forcing (fluxes, forces, G, US)
	This subroutine determines the net mass source to the ocean from a (thermodynamic) forcing type and stores it in a mech_forcing type. More...
subroutine, public	get_net_mass_forcing (fluxes, G, US, net_mass_src)
	This subroutine calculates determines the net mass source to the ocean from a (thermodynamic) forcing type and stores it in a provided array. More...
subroutine, public	copy_back_forcing_fields (fluxes, forces, G)
	This subroutine copies the computational domains of common forcing fields from a mech_forcing type to a (thermodynamic) forcing type. More...
subroutine, public	mech_forcing_diags (forces, dt, G, time_end, diag, handles)
	Offer mechanical forcing fields for diagnostics for those fields registered as part of register_forcing_type_diags. More...
subroutine, public	forcing_diagnostics (fluxes, sfc_state, G, US, time_end, diag, handles)
	Offer buoyancy forcing fields for diagnostics for those fields registered as part of register_forcing_type_diags. More...
subroutine, public	allocate_forcing_type (G, fluxes, water, heat, ustar, press, shelf, iceberg, salt)
	Conditionally allocate fields within the forcing type. More...
subroutine, public	allocate_mech_forcing (G, forces, stress, ustar, shelf, press, iceberg)
	Conditionally allocate fields within the mechanical forcing type. More...
subroutine	myalloc (array, is, ie, js, je, flag)
	Allocates and zeroes-out array. More...
subroutine, public	deallocate_forcing_type (fluxes)
	Deallocate the forcing type. More...
subroutine, public	deallocate_mech_forcing (forces)
	Deallocate the mechanical forcing type. More...

Function/Subroutine Documentation

allocate_forcing_type()

subroutine, public mom_forcing_type::allocate_forcing_type	(	type(ocean_grid_type), intent(in)	G,
		type(forcing), intent(inout)	fluxes,
		logical, intent(in), optional	water,
		logical, intent(in), optional	heat,
		logical, intent(in), optional	ustar,
		logical, intent(in), optional	press,
		logical, intent(in), optional	shelf,
		logical, intent(in), optional	iceberg,
		logical, intent(in), optional	salt
	)

Conditionally allocate fields within the forcing type.

Parameters

[in]	g	Ocean grid structure
[in,out]	fluxes	A structure containing thermodynamic forcing fields
[in]	water	If present and true, allocate water fluxes
[in]	heat	If present and true, allocate heat fluxes
[in]	ustar	If present and true, allocate ustar and related fields
[in]	press	If present and true, allocate p_surf and related fields
[in]	shelf	If present and true, allocate fluxes for ice-shelf
[in]	iceberg	If present and true, allocate fluxes for icebergs
[in]	salt	If present and true, allocate salt fluxes

Definition at line 2811 of file MOM_forcing_type.F90.

  type(ocean_grid_type), intent(in) :: G       !< Ocean grid structure
  type(forcing),      intent(inout) :: fluxes  !< A structure containing thermodynamic forcing fields
  logical, optional,     intent(in) :: water   !< If present and true, allocate water fluxes
  logical, optional,     intent(in) :: heat    !< If present and true, allocate heat fluxes
  logical, optional,     intent(in) :: ustar   !< If present and true, allocate ustar and related fields
  logical, optional,     intent(in) :: press   !< If present and true, allocate p_surf and related fields
  logical, optional,     intent(in) :: shelf   !< If present and true, allocate fluxes for ice-shelf
  logical, optional,     intent(in) :: iceberg !< If present and true, allocate fluxes for icebergs
  logical, optional,     intent(in) :: salt    !< If present and true, allocate salt fluxes
 
  ! Local variables
  integer :: isd, ied, jsd, jed, IsdB, IedB, JsdB, JedB
  logical :: heat_water
 
  isd  = g%isd   ; ied  = g%ied    ; jsd  = g%jsd   ; jed  = g%jed
  isdb = g%IsdB  ; iedb = g%IedB   ; jsdb = g%JsdB  ; jedb = g%JedB
 
  call myalloc(fluxes%ustar,isd,ied,jsd,jed, ustar)
  call myalloc(fluxes%ustar_gustless,isd,ied,jsd,jed, ustar)
 
  call myalloc(fluxes%evap,isd,ied,jsd,jed, water)
  call myalloc(fluxes%lprec,isd,ied,jsd,jed, water)
  call myalloc(fluxes%fprec,isd,ied,jsd,jed, water)
  call myalloc(fluxes%vprec,isd,ied,jsd,jed, water)
  call myalloc(fluxes%lrunoff,isd,ied,jsd,jed, water)
  call myalloc(fluxes%frunoff,isd,ied,jsd,jed, water)
  call myalloc(fluxes%seaice_melt,isd,ied,jsd,jed, water)
  call myalloc(fluxes%netMassOut,isd,ied,jsd,jed, water)
  call myalloc(fluxes%netMassIn,isd,ied,jsd,jed, water)
  call myalloc(fluxes%netSalt,isd,ied,jsd,jed, water)
  call myalloc(fluxes%seaice_melt_heat,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%sw,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%lw,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%latent,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%sens,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%latent_evap_diag,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%latent_fprec_diag,isd,ied,jsd,jed, heat)
  call myalloc(fluxes%latent_frunoff_diag,isd,ied,jsd,jed, heat)
 
  call myalloc(fluxes%salt_flux,isd,ied,jsd,jed, salt)
 
  if (present(heat) .and. present(water)) then ; if (heat .and. water) then
    call myalloc(fluxes%heat_content_cond,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_icemelt,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_lprec,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_fprec,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_vprec,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_lrunoff,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_frunoff,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_massout,isd,ied,jsd,jed, .true.)
    call myalloc(fluxes%heat_content_massin,isd,ied,jsd,jed, .true.)
  endif ; endif
 
  call myalloc(fluxes%p_surf,isd,ied,jsd,jed, press)
 
  call myalloc(fluxes%frac_shelf_h,isd,ied,jsd,jed, shelf)
  call myalloc(fluxes%ustar_shelf,isd,ied,jsd,jed, shelf)
  call myalloc(fluxes%iceshelf_melt,isd,ied,jsd,jed, shelf)
 
  !These fields should only on allocated when iceberg area is being passed through the coupler.
  call myalloc(fluxes%ustar_berg,isd,ied,jsd,jed, iceberg)
  call myalloc(fluxes%area_berg,isd,ied,jsd,jed, iceberg)
  call myalloc(fluxes%mass_berg,isd,ied,jsd,jed, iceberg)
 

References myalloc().

Here is the call graph for this function:

allocate_mech_forcing()

subroutine, public mom_forcing_type::allocate_mech_forcing	(	type(ocean_grid_type), intent(in)	G,
		type(mech_forcing), intent(inout)	forces,
		logical, intent(in), optional	stress,
		logical, intent(in), optional	ustar,
		logical, intent(in), optional	shelf,
		logical, intent(in), optional	press,
		logical, intent(in), optional	iceberg
	)

Conditionally allocate fields within the mechanical forcing type.

Parameters

[in]	g	Ocean grid structure
[in,out]	forces	Forcing fields structure
[in]	stress	If present and true, allocate taux, tauy
[in]	ustar	If present and true, allocate ustar and related fields
[in]	shelf	If present and true, allocate forces for ice-shelf
[in]	press	If present and true, allocate p_surf and related fields
[in]	iceberg	If present and true, allocate forces for icebergs

Definition at line 2879 of file MOM_forcing_type.F90.

  type(ocean_grid_type), intent(in) :: G       !< Ocean grid structure
  type(mech_forcing), intent(inout) :: forces  !< Forcing fields structure
 
  logical, optional,     intent(in) :: stress  !< If present and true, allocate taux, tauy
  logical, optional,     intent(in) :: ustar   !< If present and true, allocate ustar and related fields
  logical, optional,     intent(in) :: shelf   !< If present and true, allocate forces for ice-shelf
  logical, optional,     intent(in) :: press   !< If present and true, allocate p_surf and related fields
  logical, optional,     intent(in) :: iceberg !< If present and true, allocate forces for icebergs
 
  ! Local variables
  integer :: isd, ied, jsd, jed, IsdB, IedB, JsdB, JedB
  logical :: heat_water
 
  isd  = g%isd   ; ied  = g%ied    ; jsd  = g%jsd   ; jed  = g%jed
  isdb = g%IsdB  ; iedb = g%IedB   ; jsdb = g%JsdB  ; jedb = g%JedB
 
  call myalloc(forces%taux,isdb,iedb,jsd,jed, stress)
  call myalloc(forces%tauy,isd,ied,jsdb,jedb, stress)
 
  call myalloc(forces%ustar,isd,ied,jsd,jed, ustar)
 
  call myalloc(forces%p_surf,isd,ied,jsd,jed, press)
  call myalloc(forces%p_surf_full,isd,ied,jsd,jed, press)
  call myalloc(forces%net_mass_src,isd,ied,jsd,jed, press)
 
  call myalloc(forces%rigidity_ice_u,isdb,iedb,jsd,jed, shelf)
  call myalloc(forces%rigidity_ice_v,isd,ied,jsdb,jedb, shelf)
  call myalloc(forces%frac_shelf_u,isdb,iedb,jsd,jed, shelf)
  call myalloc(forces%frac_shelf_v,isd,ied,jsdb,jedb, shelf)
 
  !These fields should only on allocated when iceberg area is being passed through the coupler.
  call myalloc(forces%area_berg,isd,ied,jsd,jed, iceberg)
  call myalloc(forces%mass_berg,isd,ied,jsd,jed, iceberg)
 

References myalloc().

Referenced by mom_surface_forcing_nuopc::convert_iob_to_forces(), mom_surface_forcing_mct::convert_iob_to_forces(), idealized_hurricane::idealized_hurricane_wind_forcing(), neverland_surface_forcing::neverland_wind_forcing(), idealized_hurricane::scm_idealized_hurricane_wind_forcing(), mom_surface_forcing::set_forcing(), user_surface_forcing::user_wind_forcing(), and mom_surface_forcing::wind_forcing_by_data_override().

Here is the call graph for this function:

Here is the caller graph for this function:

calculatebuoyancyflux1d()

subroutine, public mom_forcing_type::calculatebuoyancyflux1d	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(forcing), intent(inout)	fluxes,
		type(optics_type), pointer	optics,
		integer, intent(in)	nsw,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	Temp,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	Salt,
		type(thermo_var_ptrs), intent(inout)	tv,
		integer, intent(in)	j,
		real, dimension( g %isd: g %ied, g %ke+1), intent(inout)	buoyancyFlux,
		real, dimension( g %isd: g %ied), intent(inout)	netHeatMinusSW,
		real, dimension( g %isd: g %ied), intent(inout)	netSalt,
		logical, intent(in), optional	skip_diags
	)

This routine calculates surface buoyancy flux by adding up the heat, FW & salt fluxes. These are actual fluxes, with units of stuff per time. Setting dt=1 in the call to extractFluxes routine allows us to get "stuf per time" rather than the time integrated fluxes needed in other routines that call extractFluxes.

Parameters

[in]	g	ocean grid
[in]	gv	ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in,out]	fluxes	surface fluxes
	optics	penetrating SW optics
[in]	nsw	The number of frequency bands of penetrating shortwave radiation
[in]	h	layer thickness [H ~> m or kg m-2]
[in]	temp	prognostic temp [degC]
[in]	salt	salinity [ppt]
[in,out]	tv	thermodynamics type
[in]	j	j-row to work on
[in,out]	buoyancyflux	buoyancy fluxes [L2 T-3 ~> m2 s-3]
[in,out]	netheatminussw	surf Heat flux [degC H s-1 ~> degC m s-1 or degC kg m-2 s-1]
[in,out]	netsalt	surf salt flux [ppt H s-1 ~> ppt m s-1 or ppt kg m-2 s-1]
[in]	skip_diags	If present and true, skip calculating diagnostics inside extractFluxes1d()

Definition at line 879 of file MOM_forcing_type.F90.

  type(ocean_grid_type),                    intent(in)    :: G              !< ocean grid
  type(verticalGrid_type),                  intent(in)    :: GV             !< ocean vertical grid structure
  type(unit_scale_type),                    intent(in)    :: US             !< A dimensional unit scaling type
  type(forcing),                            intent(inout) :: fluxes         !< surface fluxes
  type(optics_type),                        pointer       :: optics         !< penetrating SW optics
  integer,                                  intent(in)    :: nsw            !< The number of frequency bands of
                                                                            !! penetrating shortwave radiation
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in)    :: h              !< layer thickness [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in)    :: Temp           !< prognostic temp [degC]
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in)    :: Salt           !< salinity [ppt]
  type(thermo_var_ptrs),                    intent(inout) :: tv             !< thermodynamics type
  integer,                                  intent(in)    :: j              !< j-row to work on
  real, dimension(SZI_(G),SZK_(G)+1),       intent(inout) :: buoyancyFlux   !< buoyancy fluxes [L2 T-3 ~> m2 s-3]
  real, dimension(SZI_(G)),                 intent(inout) :: netHeatMinusSW !< surf Heat flux
                                                                      !! [degC H s-1 ~> degC m s-1 or degC kg m-2 s-1]
  real, dimension(SZI_(G)),                 intent(inout) :: netSalt        !< surf salt flux
                                                                      !! [ppt H s-1 ~> ppt m s-1 or ppt kg m-2 s-1]
  logical,                        optional, intent(in)    :: skip_diags     !< If present and true, skip calculating
                                                                            !! diagnostics inside extractFluxes1d()
  ! local variables
  integer                               :: start, npts, k
  real, parameter                       :: dt = 1.    ! to return a rate from extractFluxes1d
  real, dimension(SZI_(G))              :: netH       ! net FW flux [H s-1 ~> m s-1 or kg m-2 s-1]
  real, dimension(SZI_(G))              :: netEvap    ! net FW flux leaving ocean via evaporation
                                                      ! [H s-1 ~> m s-1 or kg m-2 s-1]
  real, dimension(SZI_(G))              :: netHeat    ! net temp flux [degC H s-1 ~> degC m s-2 or degC kg m-2 s-1]
  real, dimension(max(nsw,1), SZI_(G))  :: penSWbnd   ! penetrating SW radiation by band
                                                      ! [degC H ~> degC m or degC kg m-2]
  real, dimension(SZI_(G))              :: pressure   ! pressurea the surface [Pa]
  real, dimension(SZI_(G))              :: dRhodT     ! density partial derivative wrt temp [R degC-1 ~> kg m-3 degC-1]
  real, dimension(SZI_(G))              :: dRhodS     ! density partial derivative wrt saln [R ppt-1 ~> kg m-3 ppt-1]
  real, dimension(SZI_(G),SZK_(G)+1)    :: netPen     ! The net penetrating shortwave radiation at each level
                                                      ! [degC H ~> degC m or degC kg m-2]
 
  logical :: useRiverHeatContent
  logical :: useCalvingHeatContent
  real    :: depthBeforeScalingFluxes  ! A depth scale [H ~> m or kg m-2]
  real    :: GoRho ! The gravitational acceleration divided by mean density times some
                   ! unit conversion factors [L2 H-1 s R-1 T-3 ~> m4 kg-1 s-2 or m7 kg-2 s-2]
  real    :: H_limit_fluxes            ! Another depth scale [H ~> m or kg m-2]
 
  !  smg: what do we do when have heat fluxes from calving and river?
  useriverheatcontent   = .false.
  usecalvingheatcontent = .false.
 
  depthbeforescalingfluxes = max( gv%Angstrom_H, 1.e-30*gv%m_to_H )
  pressure(:) = 0. ! Ignore atmospheric pressure
  gorho       = (gv%g_Earth * gv%H_to_Z*us%T_to_s) / gv%Rho0
  start       = 1 + g%isc - g%isd
  npts        = 1 + g%iec - g%isc
 
  h_limit_fluxes = depthbeforescalingfluxes
 
  ! The surface forcing is contained in the fluxes type.
  ! We aggregate the thermodynamic forcing for a time step into the following:
  ! netH       = water added/removed via surface fluxes [H s-1 ~> m s-1 or kg m-2 s-1]
  ! netHeat    = heat via surface fluxes [degC H s-1 ~> degC m s-1 or degC kg m-2 s-1]
  ! netSalt    = salt via surface fluxes [ppt H s-1 ~> ppt m s-1 or gSalt m-2 s-1]
  ! Note that unlike other calls to extractFLuxes1d() that return the time-integrated flux
  ! this call returns the rate because dt=1
  call extractfluxes1d(g, gv, us, fluxes, optics, nsw, j, dt*us%s_to_T,                         &
                depthbeforescalingfluxes, useriverheatcontent, usecalvingheatcontent, &
                h(:,j,:), temp(:,j,:), neth, netevap, netheatminussw,                 &
                netsalt, penswbnd, tv, .false., skip_diags=skip_diags)
 
  ! Sum over bands and attenuate as a function of depth
  ! netPen is the netSW as a function of depth
  call sumswoverbands(g, gv, us, h(:,j,:), optics_nbands(optics), optics, j, dt*us%s_to_T, &
                      h_limit_fluxes, .true., penswbnd, netpen)
 
  ! Density derivatives
  call calculate_density_derivs(temp(:,j,1), salt(:,j,1), pressure, &
                                drhodt, drhods, start, npts, tv%eqn_of_state, scale=us%kg_m3_to_R)
 
  ! Adjust netSalt to reflect dilution effect of FW flux
  netsalt(g%isc:g%iec) = netsalt(g%isc:g%iec) - salt(g%isc:g%iec,j,1) * neth(g%isc:g%iec) ! ppt H/s
 
  ! Add in the SW heating for purposes of calculating the net
  ! surface buoyancy flux affecting the top layer.
  !netHeat(:) = netHeatMinusSW(:) + sum( penSWbnd, dim=1 )
  netheat(g%isc:g%iec) = netheatminussw(g%isc:g%iec) + netpen(g%isc:g%iec,1) ! K H/s
 
  ! Convert to a buoyancy flux, excluding penetrating SW heating
  buoyancyflux(g%isc:g%iec,1) = - gorho * ( drhods(g%isc:g%iec) * netsalt(g%isc:g%iec) + &
                                             drhodt(g%isc:g%iec) * netheat(g%isc:g%iec) ) ! [L2 T-3 ~> m2 s-3]
  ! We also have a penetrative buoyancy flux associated with penetrative SW
  do k=2, g%ke+1
    buoyancyflux(g%isc:g%iec,k) = - gorho * ( drhodt(g%isc:g%iec) * netpen(g%isc:g%iec,k) ) ! [L2 T-3 ~> m2 s-3]
  enddo
 

References extractfluxes1d(), mom_opacity::optics_nbands(), and mom_opacity::sumswoverbands().

Referenced by calculatebuoyancyflux2d().

Here is the call graph for this function:

Here is the caller graph for this function:

calculatebuoyancyflux2d()

subroutine, public mom_forcing_type::calculatebuoyancyflux2d	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(forcing), intent(inout)	fluxes,
		type(optics_type), pointer	optics,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	Temp,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	Salt,
		type(thermo_var_ptrs), intent(inout)	tv,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke+1), intent(inout)	buoyancyFlux,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(inout), optional	netHeatMinusSW,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(inout), optional	netSalt,
		logical, intent(in), optional	skip_diags
	)

Calculates surface buoyancy flux by adding up the heat, FW and salt fluxes, for 2d arrays. This is a wrapper for calculateBuoyancyFlux1d.

Parameters

[in]	g	ocean grid
[in]	gv	ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in,out]	fluxes	surface fluxes
	optics	SW ocean optics
[in]	h	layer thickness [H ~> m or kg m-2]
[in]	temp	temperature [degC]
[in]	salt	salinity [ppt]
[in,out]	tv	thermodynamics type
[in,out]	buoyancyflux	buoyancy fluxes [L2 T-3 ~> m2 s-3]
[in,out]	netheatminussw	surf temp flux [degC H ~> degC m or degC kg m-2]
[in,out]	netsalt	surf salt flux [ppt H ~> ppt m or ppt kg m-2]
[in]	skip_diags	If present and true, skip calculating diagnostics inside extractFluxes1d()

Definition at line 976 of file MOM_forcing_type.F90.

  type(ocean_grid_type),                      intent(in)    :: G      !< ocean grid
  type(verticalGrid_type),                    intent(in)    :: GV     !< ocean vertical grid structure
  type(unit_scale_type),                      intent(in)    :: US     !< A dimensional unit scaling type
  type(forcing),                              intent(inout) :: fluxes !< surface fluxes
  type(optics_type),                          pointer       :: optics !< SW ocean optics
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)),   intent(in)    :: h      !< layer thickness [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)),   intent(in)    :: Temp   !< temperature [degC]
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)),   intent(in)    :: Salt   !< salinity [ppt]
  type(thermo_var_ptrs),                      intent(inout) :: tv     !< thermodynamics type
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)+1), intent(inout) :: buoyancyFlux   !< buoyancy fluxes [L2 T-3 ~> m2 s-3]
  real, dimension(SZI_(G),SZJ_(G)), optional, intent(inout) :: netHeatMinusSW !< surf temp flux
                                                                              !! [degC H ~> degC m or degC kg m-2]
  real, dimension(SZI_(G),SZJ_(G)), optional, intent(inout) :: netSalt        !< surf salt flux
                                                                              !! [ppt H ~> ppt m or ppt kg m-2]
  logical, optional,                          intent(in)    :: skip_diags     !< If present and true, skip calculating
                                                                              !! diagnostics inside extractFluxes1d()
  ! local variables
  real, dimension( SZI_(G) ) :: netT ! net temperature flux [degC H s-1 ~> degC m s-2 or degC kg m-2 s-1]
  real, dimension( SZI_(G) ) :: netS ! net saln flux !! [ppt H s-1 ~> ppt m s-1 or ppt kg m-2 s-1]
  integer :: j
 
  nett(g%isc:g%iec) = 0. ; nets(g%isc:g%iec) = 0.
 
  !$OMP parallel do default(shared) firstprivate(netT,netS)
  do j=g%jsc,g%jec
    call calculatebuoyancyflux1d(g, gv, us, fluxes, optics, optics_nbands(optics), h, temp, salt, &
                                 tv, j, buoyancyflux(:,j,:), nett, nets, skip_diags=skip_diags)
    if (present(netheatminussw)) netheatminussw(g%isc:g%iec,j) = nett(g%isc:g%iec)
    if (present(netsalt)) netsalt(g%isc:g%iec,j) = nets(g%isc:g%iec)
  enddo
 

References calculatebuoyancyflux1d(), and mom_opacity::optics_nbands().

Referenced by mom_diabatic_driver::diabatic_ale(), mom_diabatic_driver::diabatic_ale_legacy(), and mom_diabatic_driver::layered_diabatic().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_back_forcing_fields()

subroutine, public mom_forcing_type::copy_back_forcing_fields	(	type(forcing), intent(in)	fluxes,
		type(mech_forcing), intent(inout)	forces,
		type(ocean_grid_type), intent(in)	G
	)

This subroutine copies the computational domains of common forcing fields from a mech_forcing type to a (thermodynamic) forcing type.

Parameters

[in]	fluxes	A structure containing thermodynamic forcing fields
[in,out]	forces	A structure with the driving mechanical forces
[in]	g	grid type

Definition at line 2182 of file MOM_forcing_type.F90.

  type(forcing),           intent(in)    :: fluxes   !< A structure containing thermodynamic forcing fields
  type(mech_forcing),      intent(inout) :: forces   !< A structure with the driving mechanical forces
  type(ocean_grid_type),   intent(in)    :: G        !< grid type
 
  real :: taux2, tauy2 ! Squared wind stress components [Pa2].
  integer :: i, j, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
 
  if (associated(forces%ustar) .and. associated(fluxes%ustar)) then
    do j=js,je ; do i=is,ie
      forces%ustar(i,j) = fluxes%ustar(i,j)
    enddo ; enddo
  endif
 

copy_common_forcing_fields()

subroutine, public mom_forcing_type::copy_common_forcing_fields	(	type(mech_forcing), intent(in)	forces,
		type(forcing), intent(inout)	fluxes,
		type(ocean_grid_type), intent(in)	G,
		logical, intent(in), optional	skip_pres
	)

This subroutine copies the computational domains of common forcing fields from a mech_forcing type to a (thermodynamic) forcing type.

Parameters

[in]	forces	A structure with the driving mechanical forces
[in,out]	fluxes	A structure containing thermodynamic forcing fields
[in]	g	grid type
[in]	skip_pres	If present and true, do not copy pressure fields.

Definition at line 2046 of file MOM_forcing_type.F90.

  type(mech_forcing),      intent(in)    :: forces   !< A structure with the driving mechanical forces
  type(forcing),           intent(inout) :: fluxes   !< A structure containing thermodynamic forcing fields
  type(ocean_grid_type),   intent(in)    :: G        !< grid type
  logical,       optional, intent(in)    :: skip_pres !< If present and true, do not copy pressure fields.
 
  real :: taux2, tauy2 ! Squared wind stress components [Pa2].
  logical :: do_pres
  integer :: i, j, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
 
  do_pres = .true. ; if (present(skip_pres)) do_pres = .not.skip_pres
 
  if (associated(forces%ustar) .and. associated(fluxes%ustar)) then
    do j=js,je ; do i=is,ie
      fluxes%ustar(i,j) = forces%ustar(i,j)
    enddo ; enddo
  endif
 
  if (do_pres) then
    if (associated(forces%p_surf) .and. associated(fluxes%p_surf)) then
      do j=js,je ; do i=is,ie
        fluxes%p_surf(i,j) = forces%p_surf(i,j)
      enddo ; enddo
    endif
 
    if (associated(forces%p_surf_full) .and. associated(fluxes%p_surf_full)) then
      do j=js,je ; do i=is,ie
        fluxes%p_surf_full(i,j) = forces%p_surf_full(i,j)
      enddo ; enddo
    endif
 
    if (associated(forces%p_surf_SSH, forces%p_surf_full)) then
      fluxes%p_surf_SSH => fluxes%p_surf_full
    elseif (associated(forces%p_surf_SSH, forces%p_surf)) then
      fluxes%p_surf_SSH => fluxes%p_surf
    endif
  endif
 

deallocate_forcing_type()

subroutine, public mom_forcing_type::deallocate_forcing_type

(

type(forcing), intent(inout)

fluxes

)

Deallocate the forcing type.

Parameters

[in,out]

fluxes

Forcing fields structure

Definition at line 2931 of file MOM_forcing_type.F90.

  type(forcing), intent(inout) :: fluxes !< Forcing fields structure
 
  if (associated(fluxes%ustar))                deallocate(fluxes%ustar)
  if (associated(fluxes%ustar_gustless))       deallocate(fluxes%ustar_gustless)
  if (associated(fluxes%buoy))                 deallocate(fluxes%buoy)
  if (associated(fluxes%sw))                   deallocate(fluxes%sw)
  if (associated(fluxes%seaice_melt_heat))     deallocate(fluxes%seaice_melt_heat)
  if (associated(fluxes%sw_vis_dir))           deallocate(fluxes%sw_vis_dir)
  if (associated(fluxes%sw_vis_dif))           deallocate(fluxes%sw_vis_dif)
  if (associated(fluxes%sw_nir_dir))           deallocate(fluxes%sw_nir_dir)
  if (associated(fluxes%sw_nir_dif))           deallocate(fluxes%sw_nir_dif)
  if (associated(fluxes%lw))                   deallocate(fluxes%lw)
  if (associated(fluxes%latent))               deallocate(fluxes%latent)
  if (associated(fluxes%latent_evap_diag))     deallocate(fluxes%latent_evap_diag)
  if (associated(fluxes%latent_fprec_diag))    deallocate(fluxes%latent_fprec_diag)
  if (associated(fluxes%latent_frunoff_diag))  deallocate(fluxes%latent_frunoff_diag)
  if (associated(fluxes%sens))                 deallocate(fluxes%sens)
  if (associated(fluxes%heat_added))           deallocate(fluxes%heat_added)
  if (associated(fluxes%heat_content_lrunoff)) deallocate(fluxes%heat_content_lrunoff)
  if (associated(fluxes%heat_content_frunoff)) deallocate(fluxes%heat_content_frunoff)
  if (associated(fluxes%heat_content_icemelt)) deallocate(fluxes%heat_content_icemelt)
  if (associated(fluxes%heat_content_lprec))   deallocate(fluxes%heat_content_lprec)
  if (associated(fluxes%heat_content_fprec))   deallocate(fluxes%heat_content_fprec)
  if (associated(fluxes%heat_content_cond))    deallocate(fluxes%heat_content_cond)
  if (associated(fluxes%heat_content_massout)) deallocate(fluxes%heat_content_massout)
  if (associated(fluxes%heat_content_massin))  deallocate(fluxes%heat_content_massin)
  if (associated(fluxes%evap))                 deallocate(fluxes%evap)
  if (associated(fluxes%lprec))                deallocate(fluxes%lprec)
  if (associated(fluxes%fprec))                deallocate(fluxes%fprec)
  if (associated(fluxes%vprec))                deallocate(fluxes%vprec)
  if (associated(fluxes%lrunoff))              deallocate(fluxes%lrunoff)
  if (associated(fluxes%frunoff))              deallocate(fluxes%frunoff)
  if (associated(fluxes%seaice_melt))          deallocate(fluxes%seaice_melt)
  if (associated(fluxes%salt_flux))            deallocate(fluxes%salt_flux)
  if (associated(fluxes%p_surf_full))          deallocate(fluxes%p_surf_full)
  if (associated(fluxes%p_surf))               deallocate(fluxes%p_surf)
  if (associated(fluxes%TKE_tidal))            deallocate(fluxes%TKE_tidal)
  if (associated(fluxes%ustar_tidal))          deallocate(fluxes%ustar_tidal)
  if (associated(fluxes%ustar_shelf))          deallocate(fluxes%ustar_shelf)
  if (associated(fluxes%iceshelf_melt))        deallocate(fluxes%iceshelf_melt)
  if (associated(fluxes%frac_shelf_h))         deallocate(fluxes%frac_shelf_h)
  if (associated(fluxes%ustar_berg))           deallocate(fluxes%ustar_berg)
  if (associated(fluxes%area_berg))            deallocate(fluxes%area_berg)
  if (associated(fluxes%mass_berg))            deallocate(fluxes%mass_berg)
 
  call coupler_type_destructor(fluxes%tr_fluxes)
 

deallocate_mech_forcing()

subroutine, public mom_forcing_type::deallocate_mech_forcing

(

type(mech_forcing), intent(inout)

forces

)

Deallocate the mechanical forcing type.

Parameters

[in,out]

forces

Forcing fields structure

Definition at line 2983 of file MOM_forcing_type.F90.

  type(mech_forcing), intent(inout) :: forces  !< Forcing fields structure
 
  if (associated(forces%taux))  deallocate(forces%taux)
  if (associated(forces%tauy))  deallocate(forces%tauy)
  if (associated(forces%ustar)) deallocate(forces%ustar)
  if (associated(forces%p_surf))         deallocate(forces%p_surf)
  if (associated(forces%p_surf_full))    deallocate(forces%p_surf_full)
  if (associated(forces%net_mass_src))   deallocate(forces%net_mass_src)
  if (associated(forces%rigidity_ice_u)) deallocate(forces%rigidity_ice_u)
  if (associated(forces%rigidity_ice_v)) deallocate(forces%rigidity_ice_v)
  if (associated(forces%frac_shelf_u))   deallocate(forces%frac_shelf_u)
  if (associated(forces%frac_shelf_v))   deallocate(forces%frac_shelf_v)
  if (associated(forces%area_berg))      deallocate(forces%area_berg)
  if (associated(forces%mass_berg))      deallocate(forces%mass_berg)
 

extractfluxes1d()

subroutine, public mom_forcing_type::extractfluxes1d	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(forcing), intent(inout)	fluxes,
		type(optics_type), pointer	optics,
		integer, intent(in)	nsw,
		integer, intent(in)	j,
		real, intent(in)	dt_in_T,
		real, intent(in)	FluxRescaleDepth,
		logical, intent(in)	useRiverHeatContent,
		logical, intent(in)	useCalvingHeatContent,
		real, dimension( g %isd: g %ied, g %ke), intent(in)	h,
		real, dimension( g %isd: g %ied, g %ke), intent(in)	T,
		real, dimension( g %isd: g %ied), intent(out)	netMassInOut,
		real, dimension( g %isd: g %ied), intent(out)	netMassOut,
		real, dimension( g %isd: g %ied), intent(out)	net_heat,
		real, dimension( g %isd: g %ied), intent(out)	net_salt,
		real, dimension(max(1,nsw),g%isd:g%ied), intent(out)	pen_SW_bnd,
		type(thermo_var_ptrs), intent(inout)	tv,
		logical, intent(in)	aggregate_FW,
		real, dimension( g %isd: g %ied), intent(out), optional	nonpenSW,
		real, dimension( g %isd: g %ied), intent(out), optional	netmassInOut_rate,
		real, dimension( g %isd: g %ied), intent(out), optional	net_Heat_Rate,
		real, dimension( g %isd: g %ied), intent(out), optional	net_salt_rate,
		real, dimension(max(1,nsw),g%isd:g%ied), intent(out), optional	pen_sw_bnd_Rate,
		logical, intent(in), optional	skip_diags
	)

This subroutine extracts fluxes from the surface fluxes type. It works on a j-row for optimization purposes. The 2d (i,j) wrapper is the next subroutine below. This routine multiplies fluxes by dt, so that the result is an accumulation of fluxes over a time step.

Parameters

[in]	g	ocean grid structure
[in]	gv	ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in,out]	fluxes	structure containing pointers to possible forcing fields. NULL unused fields.
	optics	pointer to optics
[in]	nsw	number of bands of penetrating SW
[in]	j	j-index to work on
[in]	dt_in_t	The time step for these fluxes [T ~> s]
[in]	fluxrescaledepth	min ocean depth before fluxes are scaled away [H ~> m or kg m-2]
[in]	useriverheatcontent	logical for river heat content
[in]	usecalvingheatcontent	logical for calving heat content
[in]	h	layer thickness [H ~> m or kg m-2]
[in]	t	layer temperatures [degC]
[out]	netmassinout	net mass flux (non-Bouss) or volume flux (if Bouss) of water in/out of ocean over a time step [H ~> m or kg m-2]
[out]	netmassout	net mass flux (non-Bouss) or volume flux (if Bouss) of water leaving ocean surface over a time step [H ~> m or kg m-2]. netMassOut < 0 means mass leaves ocean.
[out]	net_heat	net heat at the surface accumulated over a time step for coupler + restoring. Exclude two terms from net_heat: (1) downwelling (penetrative) SW, (2) evaporation heat content, (since do not yet know evap temperature). [degC H ~> degC m or degC kg m-2].
[out]	net_salt	surface salt flux into the ocean accumulated over a time step [ppt H ~> ppt m or ppt kg m-2].
[out]	pen_sw_bnd	penetrating SW flux, split into bands. [degC H ~> degC m or degC kg m-2] and array size nsw x G isd: G ied, where nsw=number of SW bands in pen_SW_bnd. This heat flux is not part of net_heat.
[in,out]	tv	structure containing pointers to available thermodynamic fields. Used to keep track of the heat flux associated with net mass fluxes into the ocean.
[in]	aggregate_fw	For determining how to aggregate forcing.
[out]	nonpensw	Non-penetrating SW used in net_heat
[out]	net_heat_rate	Rate of net surface heating
[out]	net_salt_rate	Surface salt flux into the ocean
[out]	netmassinout_rate	Rate of net mass flux into the ocean
[out]	pen_sw_bnd_rate	Rate of penetrative shortwave heating
[in]	skip_diags	If present and true, skip calculating diagnostics

Definition at line 346 of file MOM_forcing_type.F90.

 
  type(ocean_grid_type),    intent(in)    :: G              !< ocean grid structure
  type(verticalGrid_type),  intent(in)    :: GV             !< ocean vertical grid structure
  type(unit_scale_type),    intent(in)    :: US             !< A dimensional unit scaling type
  type(forcing),            intent(inout) :: fluxes         !< structure containing pointers to possible
                                                            !! forcing fields. NULL unused fields.
  type(optics_type),        pointer       :: optics         !< pointer to optics
  integer,                  intent(in)    :: nsw            !< number of bands of penetrating SW
  integer,                  intent(in)    :: j              !< j-index to work on
  real,                     intent(in)    :: dt_in_T        !< The time step for these fluxes [T ~> s]
  real,                     intent(in)    :: FluxRescaleDepth !< min ocean depth before fluxes
                                                            !! are scaled away [H ~> m or kg m-2]
  logical,                  intent(in)    :: useRiverHeatContent   !< logical for river heat content
  logical,                  intent(in)    :: useCalvingHeatContent !< logical for calving heat content
  real, dimension(SZI_(G),SZK_(G)), &
                            intent(in)    :: h              !< layer thickness [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZK_(G)), &
                            intent(in)    :: T              !< layer temperatures [degC]
  real, dimension(SZI_(G)), intent(out)   :: netMassInOut   !< net mass flux (non-Bouss) or volume flux
                                                            !! (if Bouss) of water in/out of ocean over
                                                            !! a time step [H ~> m or kg m-2]
  real, dimension(SZI_(G)), intent(out)   :: netMassOut     !< net mass flux (non-Bouss) or volume flux
                                                            !! (if Bouss) of water leaving ocean surface
                                                            !! over a time step [H ~> m or kg m-2].
                                                            !! netMassOut < 0 means mass leaves ocean.
  real, dimension(SZI_(G)), intent(out)   :: net_heat       !< net heat at the surface accumulated over a
                                                            !! time step for coupler + restoring.
                                                            !! Exclude two terms from net_heat:
                                                            !! (1) downwelling (penetrative) SW,
                                                            !! (2) evaporation heat content,
                                                            !! (since do not yet know evap temperature).
                                                            !! [degC H ~> degC m or degC kg m-2].
  real, dimension(SZI_(G)), intent(out)   :: net_salt       !< surface salt flux into the ocean
                                                            !! accumulated over a time step
                                                            !! [ppt H ~> ppt m or ppt kg m-2].
  real, dimension(max(1,nsw),G%isd:G%ied), intent(out) :: pen_SW_bnd !< penetrating SW flux, split into bands.
                                                            !! [degC H ~> degC m or degC kg m-2]
                                                            !! and array size nsw x SZI_(G), where
                                                            !! nsw=number of SW bands in pen_SW_bnd.
                                                            !! This heat flux is not part of net_heat.
  type(thermo_var_ptrs),    intent(inout) :: tv             !< structure containing pointers to available
                                                            !! thermodynamic fields. Used to keep
                                                            !! track of the heat flux associated with net
                                                            !! mass fluxes into the ocean.
  logical,                  intent(in)    :: aggregate_FW   !< For determining how to aggregate forcing.
  real, dimension(SZI_(G)), &
                  optional, intent(out)   :: nonpenSW       !< Non-penetrating SW used in net_heat
                                                            !! [degC H ~> degC m or degC kg m-2].
                                                            !! Summed over SW bands when diagnosing nonpenSW.
  real, dimension(SZI_(G)), &
                  optional, intent(out)   :: net_Heat_rate  !< Rate of net surface heating
                                                            !! [degC H T-1 ~> degC m s-1 or degC kg m-2 s-1].
  real, dimension(SZI_(G)), &
                  optional, intent(out)   :: net_salt_rate  !< Surface salt flux into the ocean
                                                            !! [ppt H T-1 ~> ppt m s-1 or ppt kg m-2 s-1].
  real, dimension(SZI_(G)), &
                  optional, intent(out)   :: netmassInOut_rate !< Rate of net mass flux into the ocean
                                                            !! [H T-1 ~> m s-1 or kg m-2 s-1].
  real, dimension(max(1,nsw),G%isd:G%ied), &
                  optional, intent(out)   :: pen_sw_bnd_rate !< Rate of penetrative shortwave heating
                                                             !! [degC H T-1 ~> degC m s-1 or degC kg m-2 s-1].
  logical,        optional, intent(in)    :: skip_diags      !< If present and true, skip calculating diagnostics
 
  ! local
  real :: htot(SZI_(G))       ! total ocean depth [H ~> m or kg m-2]
  real :: Pen_sw_tot(SZI_(G)) ! sum across all bands of Pen_SW [degC H ~> degC m or degC kg m-2].
  real :: pen_sw_tot_rate(SZI_(G)) ! Summed rate of shortwave heating across bands
                              ! [degC H T-1 ~> degC m s-1 or degC kg m-2 s-1]
  real :: Ih_limit            ! inverse depth at which surface fluxes start to be limited
                              ! or 0 for no limiting [H-1 ~> m-1 or m2 kg-1]
  real :: scale               ! scale scales away fluxes if depth < FluxRescaleDepth
  real :: W_m2_to_H_T         ! converts W/m^2 to H degC T-1 [degC H T-1 W-2 m2 ~> degC m3 J-1 or degC kg J-1]
  real :: RZ_T_to_W_m2_degC   ! Converts mass fluxes to heat fluxes per degree temperature
                              ! change [W m-2 degC-1 T R-1 Z-1 ~> J kg degC]
  real :: I_Cp                ! 1.0 / C_p [kg decC J-1]
  real :: RZcp_to_H           ! Unit convsersion factors divided by the heat capacity
                              ! [kg degC H R-1 Z-1 J-1 ~> degC m3 J-1 or kg degC J-1]
  logical :: calculate_diags  ! Indicate to calculate/update diagnostic arrays
  character(len=200) :: mesg
  integer            :: is, ie, nz, i, k, n
 
  logical :: do_NHR, do_NSR, do_NMIOR, do_PSWBR
 
  !BGR-Jul 5,2017{
  ! Initializes/sets logicals if 'rates' are requested
  ! These factors are required for legacy reasons
  !  and therefore computed only when optional outputs are requested
  do_nhr = .false.
  do_nsr = .false.
  do_nmior = .false.
  do_pswbr = .false.
  if (present(net_heat_rate)) do_nhr = .true.
  if (present(net_salt_rate)) do_nsr = .true.
  if (present(netmassinout_rate)) do_nmior = .true.
  if (present(pen_sw_bnd_rate)) do_pswbr = .true.
  !}BGR
 
  ih_limit  = 0.0 ; if (fluxrescaledepth > 0.0) ih_limit  = 1.0 / fluxrescaledepth
  rz_t_to_w_m2_degc = fluxes%C_p*us%R_to_kg_m3*us%Z_to_m*us%s_to_T
  i_cp      = 1.0 / fluxes%C_p
  w_m2_to_h_t = 1.0 / (us%s_to_T * gv%H_to_kg_m2 * fluxes%C_p)
 
  rzcp_to_h = 1.0 / (gv%H_to_RZ * fluxes%C_p)
 
  is = g%isc ; ie = g%iec ; nz = g%ke
 
  calculate_diags = .true.
  if (present(skip_diags)) calculate_diags = .not. skip_diags
 
  ! error checking
 
  if (nsw > 0) then ; if (nsw /= optics_nbands(optics)) call mom_error(warning, &
    "mismatch in the number of bands of shortwave radiation in MOM_forcing_type extract_fluxes.")
  endif
 
  if (.not.associated(fluxes%sw)) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: fluxes%sw is not associated.")
 
  if (.not.associated(fluxes%lw)) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: fluxes%lw is not associated.")
 
  if (.not.associated(fluxes%latent)) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: fluxes%latent is not associated.")
 
  if (.not.associated(fluxes%sens)) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: fluxes%sens is not associated.")
 
  if (.not.associated(fluxes%evap)) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: No evaporation defined.")
 
  if (.not.associated(fluxes%vprec)) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: fluxes%vprec not defined.")
 
  if ((.not.associated(fluxes%lprec)) .or. &
      (.not.associated(fluxes%fprec))) call mom_error(fatal, &
    "MOM_forcing_type extractFluxes1d: No precipitation defined.")
 
  do i=is,ie ; htot(i) = h(i,1) ; enddo
  do k=2,nz ; do i=is,ie ; htot(i) = htot(i) + h(i,k) ; enddo ; enddo
 
  if (nsw >= 1) then
    call extract_optics_slice(optics, j, g, gv, pensw_top=pen_sw_bnd) !, penSW_scale=W_m2_to_H_T*dt_in_T
    if (do_pswbr) call extract_optics_slice(optics, j, g, gv, pensw_top=pen_sw_bnd_rate) !, penSW_scale=W_m2_to_H_T
  endif
 
  do i=is,ie
 
    scale = 1.0 ; if ((ih_limit > 0.0) .and. (htot(i)*ih_limit < 1.0)) scale = htot(i)*ih_limit
 
    ! Convert the penetrating shortwave forcing to (K * H) and reduce fluxes for shallow depths.
    ! (H=m for Bouss, H=kg/m2 for non-Bouss)
    pen_sw_tot(i) = 0.0
    if (nsw >= 1) then
     do n=1,nsw
        pen_sw_bnd(n,i) = w_m2_to_h_t*scale*dt_in_t * max(0.0, pen_sw_bnd(n,i))
        pen_sw_tot(i)   = pen_sw_tot(i) + pen_sw_bnd(n,i)
      enddo
    else
      pen_sw_bnd(1,i) = 0.0
    endif
 
    if (do_pswbr) then  ! Repeat the above code w/ dt=1s for legacy reasons
      pen_sw_tot_rate(i) = 0.0
      if (nsw >= 1) then
        do n=1,nsw
          pen_sw_bnd_rate(n,i) = w_m2_to_h_t*scale * max(0.0, pen_sw_bnd_rate(n,i))
          pen_sw_tot_rate(i) = pen_sw_tot_rate(i) + pen_sw_bnd_rate(n,i)
        enddo
      else
        pen_sw_bnd_rate(1,i) = 0.0
      endif
    endif
 
    ! net volume/mass of liquid and solid passing through surface boundary fluxes
    netmassinout(i) = dt_in_t * (scale * &
                                   (((((( fluxes%lprec(i,j)        &
                                        + fluxes%fprec(i,j)      )  &
                                        + fluxes%evap(i,j)       )  &
                                        + fluxes%lrunoff(i,j)    )  &
                                        + fluxes%vprec(i,j)      )  &
                                        + fluxes%seaice_melt(i,j))  &
                                        + fluxes%frunoff(i,j)    ))
 
    if (do_nmior) then  ! Repeat the above code without multiplying by a timestep for legacy reasons
      netmassinout_rate(i) = (scale * &
                                   (((((( fluxes%lprec(i,j)      &
                                        + fluxes%fprec(i,j)      )  &
                                        + fluxes%evap(i,j)       )  &
                                        + fluxes%lrunoff(i,j)    )  &
                                        + fluxes%vprec(i,j)      )  &
                                        + fluxes%seaice_melt(i,j))  &
                                        + fluxes%frunoff(i,j)   ))
    endif
 
    ! smg:
    ! for non-Bouss, we add/remove salt mass to total ocean mass. to conserve
    ! total salt mass ocean+ice, the sea ice model must lose mass when salt mass
    ! is added to the ocean, which may still need to be coded.  Not that the units
    ! of netMassInOut are still kg_m2, so no conversion to H should occur yet.
    if (.not.gv%Boussinesq .and. associated(fluxes%salt_flux)) then
      netmassinout(i) = netmassinout(i) + dt_in_t * (scale * fluxes%salt_flux(i,j))
      if (do_nmior) netmassinout_rate(i) = netmassinout_rate(i) + &
                                               (scale * fluxes%salt_flux(i,j))
    endif
 
    ! net volume/mass of water leaving the ocean.
    ! check that fluxes are < 0, which means mass is indeed leaving.
    netmassout(i) = 0.0
 
    ! evap > 0 means condensating water is added into ocean.
    ! evap < 0 means evaporation of water from the ocean, in
    ! which case heat_content_evap is computed in MOM_diabatic_driver.F90
    if (fluxes%evap(i,j) < 0.0) netmassout(i) = netmassout(i) + fluxes%evap(i,j)
  !   if (associated(fluxes%heat_content_cond)) fluxes%heat_content_cond(i,j) = 0.0 !??? --AJA
 
    ! lprec < 0 means sea ice formation taking water from the ocean.
    ! smg: we should split the ice melt/formation from the lprec
    if (fluxes%lprec(i,j) < 0.0) netmassout(i) = netmassout(i) + fluxes%lprec(i,j)
 
    ! seaice_melt < 0 means sea ice formation taking water from the ocean.
    if (fluxes%seaice_melt(i,j) < 0.0) netmassout(i) = netmassout(i) + fluxes%seaice_melt(i,j)
 
    ! vprec < 0 means virtual evaporation arising from surface salinity restoring,
    ! in which case heat_content_vprec is computed in MOM_diabatic_driver.F90.
    if (fluxes%vprec(i,j) < 0.0) netmassout(i) = netmassout(i) + fluxes%vprec(i,j)
 
    netmassout(i) = dt_in_t * scale * netmassout(i)
 
    ! convert to H units (Bouss=meter or non-Bouss=kg/m^2)
    netmassinout(i) = gv%RZ_to_H * netmassinout(i)
    if (do_nmior) netmassinout_rate(i) = gv%RZ_to_H * netmassinout_rate(i)
    netmassout(i)   = gv%RZ_to_H * netmassout(i)
 
    ! surface heat fluxes from radiation and turbulent fluxes (K * H)
    ! (H=m for Bouss, H=kg/m2 for non-Bouss)
 
    ! CIME provides heat flux from snow&ice melt (seaice_melt_heat), so this is added below
    if (associated(fluxes%seaice_melt_heat)) then
      net_heat(i) = scale * dt_in_t * w_m2_to_h_t * &
                    ( fluxes%sw(i,j) +  ((fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j) + &
                      fluxes%seaice_melt_heat(i,j)) )
      !Repeats above code w/ dt=1. for legacy reason
      if (do_nhr)  net_heat_rate(i) = scale * w_m2_to_h_t * &
           ( fluxes%sw(i,j) +  ((fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j) + &
             fluxes%seaice_melt_heat(i,j)))
    else
      net_heat(i) = scale * dt_in_t * w_m2_to_h_t * &
                    ( fluxes%sw(i,j) +  ((fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j)) )
      !Repeats above code w/ dt=1. for legacy reason
      if (do_nhr)  net_heat_rate(i) = scale * w_m2_to_h_t * &
           ( fluxes%sw(i,j) +  ((fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j)) )
    endif
 
    ! Add heat flux from surface damping (restoring) (K * H) or flux adjustments.
    if (associated(fluxes%heat_added)) then
      net_heat(i) = net_heat(i) + (scale * (dt_in_t * w_m2_to_h_t)) * fluxes%heat_added(i,j)
      if (do_nhr) net_heat_rate(i) = net_heat_rate(i) + (scale * (w_m2_to_h_t)) * fluxes%heat_added(i,j)
    endif
 
    ! Add explicit heat flux for runoff (which is part of the ice-ocean boundary
    ! flux type). Runoff is otherwise added with a temperature of SST.
    if (useriverheatcontent) then
      ! remove lrunoff*SST here, to counteract its addition elsewhere
      net_heat(i) = (net_heat(i) + (scale*(dt_in_t * rzcp_to_h)) * fluxes%heat_content_lrunoff(i,j)) - &
                     (gv%RZ_to_H * (scale * dt_in_t)) * fluxes%lrunoff(i,j) * t(i,1)
      !BGR-Jul 5, 2017{
      !Intentionally neglect the following contribution to rate for legacy reasons.
      !if (do_NHR) net_heat_rate(i) = (net_heat_rate(i) + (scale*RZcP_to_H) * fluxes%heat_content_lrunoff(i,j)) - &
      !               (GV%RZ_to_H * (scale)) * fluxes%lrunoff(i,j) * T(i,1)
      !}BGR
      if (calculate_diags .and. associated(tv%TempxPmE)) then
        tv%TempxPmE(i,j) = tv%TempxPmE(i,j) + (scale * dt_in_t) * &
            (i_cp*fluxes%heat_content_lrunoff(i,j) - fluxes%lrunoff(i,j)*t(i,1))
      endif
    endif
 
    ! Add explicit heat flux for calving (which is part of the ice-ocean boundary
    ! flux type). Calving is otherwise added with a temperature of SST.
    if (usecalvingheatcontent) then
      ! remove frunoff*SST here, to counteract its addition elsewhere
      net_heat(i) = net_heat(i) + (scale*(dt_in_t * rzcp_to_h)) * fluxes%heat_content_frunoff(i,j) - &
                    (gv%RZ_to_H * (scale * dt_in_t)) * fluxes%frunoff(i,j) * t(i,1)
      !BGR-Jul 5, 2017{
      !Intentionally neglect the following contribution to rate for legacy reasons.
!      if (do_NHR) net_heat_rate(i) = net_heat_rate(i) + (scale*RZcP_to_H) * fluxes%heat_content_frunoff(i,j) - &
!                    (GV%RZ_to_H * scale) * fluxes%frunoff(i,j) * T(i,1)
      !}BGR
      if (calculate_diags .and. associated(tv%TempxPmE)) then
        tv%TempxPmE(i,j) = tv%TempxPmE(i,j) + (scale * dt_in_t) * &
            (i_cp*fluxes%heat_content_frunoff(i,j) - fluxes%frunoff(i,j)*t(i,1))
      endif
    endif
 
! smg: new code
    ! add heat from all terms that may add mass to the ocean (K * H).
    ! if evap, lprec, or vprec < 0, then compute their heat content
    ! inside MOM_diabatic_driver.F90 and fill in fluxes%heat_content_massout.
    ! we do so since we do not here know the temperature
    ! of water leaving the ocean, as it could be leaving from more than
    ! one layer of the upper ocean in the case of very thin layers.
    ! When evap, lprec, or vprec > 0, then we know their heat content here
    ! via settings from inside of the appropriate config_src driver files.
!    if (associated(fluxes%heat_content_lprec)) then
!      net_heat(i) = net_heat(i) + scale * dt_in_T * RZcP_to_H * &
!     (fluxes%heat_content_lprec(i,j)    + (fluxes%heat_content_fprec(i,j)   + &
!     (fluxes%heat_content_lrunoff(i,j)  + (fluxes%heat_content_frunoff(i,j) + &
!     (fluxes%heat_content_cond(i,j)     +  fluxes%heat_content_vprec(i,j))))))
!    endif
 
    if (fluxes%num_msg < fluxes%max_msg) then
      if (pen_sw_tot(i) > 1.000001 * w_m2_to_h_t*scale*dt_in_t*fluxes%sw(i,j)) then
        fluxes%num_msg = fluxes%num_msg + 1
        write(mesg,'("Penetrating shortwave of ",1pe17.10, &
                    &" exceeds total shortwave of ",1pe17.10,&
                    &" at ",1pg11.4,"E, "1pg11.4,"N.")') &
               pen_sw_tot(i),w_m2_to_h_t*scale*dt_in_t * fluxes%sw(i,j),&
               g%geoLonT(i,j),g%geoLatT(i,j)
        call mom_error(warning,mesg)
      endif
    endif
 
    ! remove penetrative portion of the SW that is NOT absorbed within a
    ! tiny layer at the top of the ocean.
    net_heat(i) = net_heat(i) - pen_sw_tot(i)
    !Repeat above code for 'rate' term
    if (do_nhr) net_heat_rate(i) = net_heat_rate(i) - pen_sw_tot_rate(i)
 
    ! diagnose non-downwelling SW
    if (present(nonpensw)) then
      nonpensw(i) = scale * dt_in_t * w_m2_to_h_t * fluxes%sw(i,j) - pen_sw_tot(i)
    endif
 
    ! Salt fluxes
    net_salt(i) = 0.0
    if (do_nsr) net_salt_rate(i) = 0.0
    ! Convert salt_flux from kg (salt)/(m^2 * s) to
    ! Boussinesq: (ppt * m)
    ! non-Bouss:  (g/m^2)
    if (associated(fluxes%salt_flux)) then
      net_salt(i) = (scale * dt_in_t * (1000.0 * fluxes%salt_flux(i,j))) * gv%RZ_to_H
      !Repeat above code for 'rate' term
      if (do_nsr) net_salt_rate(i) = (scale * 1. * (1000.0 * fluxes%salt_flux(i,j))) * gv%RZ_to_H
    endif
 
    ! Diagnostics follow...
    if (calculate_diags) then
 
      ! Store Net_salt for unknown reason?
      if (associated(fluxes%salt_flux)) then
        ! This seems like a bad idea to me. -RWH
        if (calculate_diags) fluxes%netSalt(i,j) = us%kg_m3_to_R*us%m_to_Z*us%T_to_s*net_salt(i)
      endif
 
      ! Initialize heat_content_massin that is diagnosed in mixedlayer_convection or
      ! applyBoundaryFluxes such that the meaning is as the sum of all incoming components.
      if (associated(fluxes%heat_content_massin))  then
        if (aggregate_fw) then
          if (netmassinout(i) > 0.0) then ! net is "in"
            fluxes%heat_content_massin(i,j) = -fluxes%C_p * netmassout(i) * t(i,1) * gv%H_to_RZ / dt_in_t
          else ! net is "out"
            fluxes%heat_content_massin(i,j) = fluxes%C_p * ( netmassinout(i) - netmassout(i) ) * &
                                               t(i,1) * gv%H_to_RZ / dt_in_t
          endif
        else
          fluxes%heat_content_massin(i,j) = 0.
        endif
      endif
 
      ! Initialize heat_content_massout that is diagnosed in mixedlayer_convection or
      ! applyBoundaryFluxes such that the meaning is as the sum of all outgoing components.
      if (associated(fluxes%heat_content_massout)) then
        if (aggregate_fw) then
          if (netmassinout(i) > 0.0) then ! net is "in"
            fluxes%heat_content_massout(i,j) = fluxes%C_p * netmassout(i) * t(i,1) * gv%H_to_RZ / dt_in_t
          else ! net is "out"
           fluxes%heat_content_massout(i,j) = -fluxes%C_p * ( netmassinout(i) - netmassout(i) ) * &
                                               t(i,1) * gv%H_to_RZ / dt_in_t
          endif
        else
          fluxes%heat_content_massout(i,j) = 0.0
        endif
      endif
 
      ! smg: we should remove sea ice melt from lprec!!!
      ! fluxes%lprec > 0 means ocean gains mass via liquid precipitation and/or sea ice melt.
      ! When atmosphere does not provide heat of this precipitation, the ocean assumes
      ! it enters the ocean at the SST.
      ! fluxes%lprec < 0 means ocean loses mass via sea ice formation. As we do not yet know
      ! the layer at which this mass is removed, we cannot compute it heat content. We must
      ! wait until MOM_diabatic_driver.F90.
      if (associated(fluxes%heat_content_lprec)) then
        if (fluxes%lprec(i,j) > 0.0) then
          fluxes%heat_content_lprec(i,j) = fluxes%C_p*fluxes%lprec(i,j)*t(i,1)
        else
          fluxes%heat_content_lprec(i,j) = 0.0
        endif
      endif
 
      ! fprec SHOULD enter ocean at 0degC if atmos model does not provide fprec heat content.
      ! However, we need to adjust netHeat above to reflect the difference between 0decC and SST
      ! and until we do so fprec is treated like lprec and enters at SST. -AJA
      if (associated(fluxes%heat_content_fprec)) then
        if (fluxes%fprec(i,j) > 0.0) then
          fluxes%heat_content_fprec(i,j) = fluxes%C_p*fluxes%fprec(i,j)*t(i,1)
        else
          fluxes%heat_content_fprec(i,j) = 0.0
        endif
      endif
 
      ! Following lprec and fprec, water flux due to sea ice melt (seaice_melt) enters at SST - GMM
      if (associated(fluxes%heat_content_icemelt)) then
        if (fluxes%seaice_melt(i,j) > 0.0) then
          fluxes%heat_content_icemelt(i,j) = fluxes%C_p*fluxes%seaice_melt(i,j)*t(i,1)
        else
          fluxes%heat_content_icemelt(i,j) = 0.0
        endif
      endif
 
      ! virtual precip associated with salinity restoring
      ! vprec > 0 means add water to ocean, assumed to be at SST
      ! vprec < 0 means remove water from ocean; set heat_content_vprec in MOM_diabatic_driver.F90
      if (associated(fluxes%heat_content_vprec)) then
        if (fluxes%vprec(i,j) > 0.0) then
          fluxes%heat_content_vprec(i,j) = fluxes%C_p*fluxes%vprec(i,j)*t(i,1)
        else
          fluxes%heat_content_vprec(i,j) = 0.0
        endif
      endif
 
      ! fluxes%evap < 0 means ocean loses mass due to evaporation.
      ! Evaporation leaves ocean surface at a temperature that has yet to be determined,
      ! since we do not know the precise layer that the water evaporates.  We therefore
      ! compute fluxes%heat_content_massout at the relevant point inside MOM_diabatic_driver.F90.
      ! fluxes%evap > 0 means ocean gains moisture via condensation.
      ! Condensation is assumed to drop into the ocean at the SST, just like lprec.
      if (associated(fluxes%heat_content_cond)) then
        if (fluxes%evap(i,j) > 0.0) then
          fluxes%heat_content_cond(i,j) = fluxes%C_p*fluxes%evap(i,j)*t(i,1)
        else
          fluxes%heat_content_cond(i,j) = 0.0
        endif
      endif
 
      ! Liquid runoff enters ocean at SST if land model does not provide runoff heat content.
      if (.not. useriverheatcontent) then
        if (associated(fluxes%lrunoff) .and. associated(fluxes%heat_content_lrunoff)) then
          fluxes%heat_content_lrunoff(i,j) = fluxes%C_p*fluxes%lrunoff(i,j)*t(i,1)
        endif
      endif
 
      ! Icebergs enter ocean at SST if land model does not provide calving heat content.
      if (.not. usecalvingheatcontent) then
        if (associated(fluxes%frunoff) .and. associated(fluxes%heat_content_frunoff)) then
          fluxes%heat_content_frunoff(i,j) = fluxes%C_p*fluxes%frunoff(i,j)*t(i,1)
        endif
      endif
 
    endif ! calculate_diags
 
  enddo ! i-loop
 

References mom_opacity::extract_optics_slice(), mom_error_handler::mom_error(), and mom_opacity::optics_nbands().

Referenced by mom_diabatic_aux::applyboundaryfluxesinout(), mom_bulk_mixed_layer::bulkmixedlayer(), calculatebuoyancyflux1d(), and extractfluxes2d().

Here is the call graph for this function:

Here is the caller graph for this function:

extractfluxes2d()

subroutine, public mom_forcing_type::extractfluxes2d	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(forcing), intent(inout)	fluxes,
		type(optics_type), pointer	optics,
		integer, intent(in)	nsw,
		real, intent(in)	dt_in_T,
		real, intent(in)	FluxRescaleDepth,
		logical, intent(in)	useRiverHeatContent,
		logical, intent(in)	useCalvingHeatContent,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	T,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(out)	netMassInOut,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(out)	netMassOut,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(out)	net_heat,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(out)	Net_salt,
		real, dimension(max(1,nsw),g%isd:g%ied,g%jsd:g%jed), intent(out)	Pen_SW_bnd,
		type(thermo_var_ptrs), intent(inout)	tv,
		logical, intent(in)	aggregate_FW
	)

2d wrapper for 1d extract fluxes from surface fluxes type. This subroutine extracts fluxes from the surface fluxes type. It multiplies the fluxes by dt, so that the result is an accumulation of the fluxes over a time step.

Parameters

[in]	g	ocean grid structure
[in]	gv	ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in,out]	fluxes	structure containing pointers to forcing.
	optics	pointer to optics
[in]	nsw	number of bands of penetrating SW
[in]	dt_in_t	The time step for these fluxes [T ~> s]
[in]	fluxrescaledepth	min ocean depth before fluxes are scaled away [H ~> m or kg m-2]
[in]	useriverheatcontent	logical for river heat content
[in]	usecalvingheatcontent	logical for calving heat content
[in]	h	layer thickness [H ~> m or kg m-2]
[in]	t	layer temperatures [degC]
[out]	netmassinout	net mass flux (non-Bouss) or volume flux (if Bouss) of water in/out of ocean over a time step [H ~> m or kg m-2]
[out]	netmassout	net mass flux (non-Bouss) or volume flux (if Bouss) of water leaving ocean surface over a time step [H ~> m or kg m-2].
[out]	net_heat	net heat at the surface accumulated over a time step associated with coupler + restore. Exclude two terms from net_heat: (1) downwelling (penetrative) SW, (2) evaporation heat content, (since do not yet know temperature of evap). [degC H ~> degC m or degC kg m-2]
[out]	net_salt	surface salt flux into the ocean accumulated over a time step [ppt H ~> ppt m or ppt kg m-2]
[out]	pen_sw_bnd	penetrating SW flux, by frequency band [degC H ~> degC m or degC kg m-2] with array size nsw x G isd: G ied, where nsw=number of SW bands in pen_SW_bnd. This heat flux is not in net_heat.
[in,out]	tv	structure containing pointers to available thermodynamic fields. Here it is used to keep track of the heat flux associated with net mass fluxes into the ocean.
[in]	aggregate_fw	For determining how to aggregate the forcing.

Definition at line 817 of file MOM_forcing_type.F90.

 
  type(ocean_grid_type),            intent(in)    :: G              !< ocean grid structure
  type(verticalGrid_type),          intent(in)    :: GV             !< ocean vertical grid structure
  type(unit_scale_type),            intent(in)    :: US             !< A dimensional unit scaling type
  type(forcing),                    intent(inout) :: fluxes         !< structure containing pointers to forcing.
  type(optics_type),                pointer       :: optics         !< pointer to optics
  integer,                          intent(in)    :: nsw            !< number of bands of penetrating SW
  real,                             intent(in)    :: dt_in_T        !< The time step for these fluxes [T ~> s]
  real,                             intent(in)    :: FluxRescaleDepth !< min ocean depth before fluxes
                                                                    !! are scaled away [H ~> m or kg m-2]
  logical,                          intent(in)    :: useRiverHeatContent   !< logical for river heat content
  logical,                          intent(in)    :: useCalvingHeatContent !< logical for calving heat content
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                                    intent(in)    :: h              !< layer thickness [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                                    intent(in)    :: T              !< layer temperatures [degC]
  real, dimension(SZI_(G),SZJ_(G)), intent(out)   :: netMassInOut   !< net mass flux (non-Bouss) or volume flux
                                                                    !! (if Bouss) of water in/out of ocean over
                                                                    !! a time step [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZJ_(G)), intent(out)   :: netMassOut     !< net mass flux (non-Bouss) or volume flux
                                                                    !! (if Bouss) of water leaving ocean surface
                                                                    !! over a time step [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G)), intent(out)   :: net_heat       !< net heat at the surface accumulated over a
                                                                    !! time step associated with coupler + restore.
                                                                    !! Exclude two terms from net_heat:
                                                                    !! (1) downwelling (penetrative) SW,
                                                                    !! (2) evaporation heat content,
                                                                    !! (since do not yet know temperature of evap).
                                                                    !! [degC H ~> degC m or degC kg m-2]
  real, dimension(SZI_(G),SZJ_(G)), intent(out)   :: net_salt       !< surface salt flux into the ocean accumulated
                                                                    !! over a time step [ppt H ~> ppt m or ppt kg m-2]
  real, dimension(max(1,nsw),G%isd:G%ied,G%jsd:G%jed), intent(out) :: pen_SW_bnd !< penetrating SW flux, by frequency
                                                                    !! band [degC H ~> degC m or degC kg m-2] with array
                                                                    !! size nsw x SZI_(G), where nsw=number of SW bands
                                                                    !! in pen_SW_bnd. This heat flux is not in net_heat.
  type(thermo_var_ptrs),            intent(inout) :: tv             !< structure containing pointers to available
                                                                    !! thermodynamic fields. Here it is used to keep
                                                                    !! track of the heat flux associated with net
                                                                    !! mass fluxes into the ocean.
  logical,                          intent(in)    :: aggregate_FW   !< For determining how to aggregate the forcing.
 
  integer :: j
!$OMP parallel do default(none) shared(G, GV, US, fluxes, optics, nsw, dt_in_T, FluxRescaleDepth, &
!$OMP                                  useRiverHeatContent, useCalvingHeatContent,             &
!$OMP                                  h,T,netMassInOut,netMassOut,Net_heat,Net_salt,Pen_SW_bnd,tv, &
!$OMP                                  aggregate_FW)
  do j=g%jsc, g%jec
    call extractfluxes1d(g, gv, us, fluxes, optics, nsw, j, dt_in_t, &
            fluxrescaledepth, useriverheatcontent, usecalvingheatcontent,&
            h(:,j,:), t(:,j,:), netmassinout(:,j), netmassout(:,j),              &
            net_heat(:,j), net_salt(:,j), pen_sw_bnd(:,:,j), tv, aggregate_fw)
  enddo
 

References extractfluxes1d().

Here is the call graph for this function:

fluxes_accumulate()

subroutine, public mom_forcing_type::fluxes_accumulate	(	type(forcing), intent(in)	flux_tmp,
		type(forcing), intent(inout)	fluxes,
		type(ocean_grid_type), intent(inout)	G,
		real, intent(out)	wt2,
		type(mech_forcing), intent(in), optional	forces
	)

Accumulate the thermodynamic fluxes over time steps.

Parameters

[in]	flux_tmp	A temporary structure with current thermodynamic forcing fields
[in,out]	fluxes	A structure containing time-averaged thermodynamic forcing fields
[in,out]	g	The ocean's grid structure
[out]	wt2	The relative weight of the new fluxes
[in]	forces	A structure with the driving mechanical forces

Definition at line 1901 of file MOM_forcing_type.F90.

  type(forcing),             intent(in)    :: flux_tmp !< A temporary structure with current
                                                     !! thermodynamic forcing fields
  type(forcing),             intent(inout) :: fluxes !< A structure containing time-averaged
                                                     !! thermodynamic forcing fields
  type(ocean_grid_type),     intent(inout) :: G      !< The ocean's grid structure
  real,                      intent(out)   :: wt2    !< The relative weight of the new fluxes
  type(mech_forcing), optional, intent(in) :: forces !< A structure with the driving mechanical forces
 
  ! This subroutine copies mechancal forcing from flux_tmp to fluxes and
  ! stores the time-weighted averages of the various buoyancy fluxes in fluxes,
  ! and increments the amount of time over which the buoyancy forcing in fluxes should be
  ! applied based on the time interval stored in flux_tmp.
 
  real :: wt1
  integer :: i, j, is, ie, js, je, Isq, Ieq, Jsq, Jeq, i0, j0
  integer :: isd, ied, jsd, jed, IsdB, IedB, JsdB, JedB, isr, ier, jsr, jer
  is   = g%isc   ; ie   = g%iec    ; js   = g%jsc   ; je   = g%jec
  isq  = g%IscB  ; ieq  = g%IecB   ; jsq  = g%JscB  ; jeq  = g%JecB
  isd  = g%isd   ; ied  = g%ied    ; jsd  = g%jsd   ; jed  = g%jed
  isdb = g%IsdB  ; iedb = g%IedB   ; jsdb = g%JsdB  ; jedb = g%JedB
 
 
  if (fluxes%dt_buoy_accum < 0) call mom_error(fatal, "fluxes_accumulate: "//&
     "fluxes must be initialzed before it can be augmented.")
 
  ! wt1 is the relative weight of the previous fluxes.
  wt1 = fluxes%dt_buoy_accum / (fluxes%dt_buoy_accum + flux_tmp%dt_buoy_accum)
  wt2 = 1.0 - wt1 ! = flux_tmp%dt_buoy_accum / (fluxes%dt_buoy_accum + flux_tmp%dt_buoy_accum)
  fluxes%dt_buoy_accum = fluxes%dt_buoy_accum + flux_tmp%dt_buoy_accum
 
  ! Copy over the pressure fields and accumulate averages of ustar, either from the forcing
  ! type or from the temporary fluxes type.
  if (present(forces)) then
    do j=js,je ; do i=is,ie
      fluxes%p_surf(i,j) = forces%p_surf(i,j)
      fluxes%p_surf_full(i,j) = forces%p_surf_full(i,j)
 
      fluxes%ustar(i,j) = wt1*fluxes%ustar(i,j) + wt2*forces%ustar(i,j)
    enddo ; enddo
  else
    do j=js,je ; do i=is,ie
      fluxes%p_surf(i,j) = flux_tmp%p_surf(i,j)
      fluxes%p_surf_full(i,j) = flux_tmp%p_surf_full(i,j)
 
      fluxes%ustar(i,j) = wt1*fluxes%ustar(i,j) + wt2*flux_tmp%ustar(i,j)
    enddo ; enddo
  endif
 
  ! Average the water, heat, and salt fluxes, and ustar.
  do j=js,je ; do i=is,ie
!### Replace the expression for ustar_gustless with this one...
!    fluxes%ustar_gustless(i,j) = wt1*fluxes%ustar_gustless(i,j) + wt2*flux_tmp%ustar_gustless(i,j)
    fluxes%ustar_gustless(i,j) = flux_tmp%ustar_gustless(i,j)
 
    fluxes%evap(i,j) = wt1*fluxes%evap(i,j) + wt2*flux_tmp%evap(i,j)
    fluxes%lprec(i,j) = wt1*fluxes%lprec(i,j) + wt2*flux_tmp%lprec(i,j)
    fluxes%fprec(i,j) = wt1*fluxes%fprec(i,j) + wt2*flux_tmp%fprec(i,j)
    fluxes%vprec(i,j) = wt1*fluxes%vprec(i,j) + wt2*flux_tmp%vprec(i,j)
    fluxes%lrunoff(i,j) = wt1*fluxes%lrunoff(i,j) + wt2*flux_tmp%lrunoff(i,j)
    fluxes%frunoff(i,j) = wt1*fluxes%frunoff(i,j) + wt2*flux_tmp%frunoff(i,j)
    fluxes%seaice_melt(i,j) = wt1*fluxes%seaice_melt(i,j) + wt2*flux_tmp%seaice_melt(i,j)
    fluxes%sw(i,j) = wt1*fluxes%sw(i,j) + wt2*flux_tmp%sw(i,j)
    fluxes%sw_vis_dir(i,j) = wt1*fluxes%sw_vis_dir(i,j) + wt2*flux_tmp%sw_vis_dir(i,j)
    fluxes%sw_vis_dif(i,j) = wt1*fluxes%sw_vis_dif(i,j) + wt2*flux_tmp%sw_vis_dif(i,j)
    fluxes%sw_nir_dir(i,j) = wt1*fluxes%sw_nir_dir(i,j) + wt2*flux_tmp%sw_nir_dir(i,j)
    fluxes%sw_nir_dif(i,j) = wt1*fluxes%sw_nir_dif(i,j) + wt2*flux_tmp%sw_nir_dif(i,j)
    fluxes%lw(i,j) = wt1*fluxes%lw(i,j) + wt2*flux_tmp%lw(i,j)
    fluxes%latent(i,j) = wt1*fluxes%latent(i,j) + wt2*flux_tmp%latent(i,j)
    fluxes%sens(i,j) = wt1*fluxes%sens(i,j) + wt2*flux_tmp%sens(i,j)
 
    fluxes%salt_flux(i,j) = wt1*fluxes%salt_flux(i,j) + wt2*flux_tmp%salt_flux(i,j)
  enddo ; enddo
  if (associated(fluxes%heat_added) .and. associated(flux_tmp%heat_added)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_added(i,j) = wt1*fluxes%heat_added(i,j) + wt2*flux_tmp%heat_added(i,j)
    enddo ; enddo
  endif
  ! These might always be associated, in which case they can be combined?
  if (associated(fluxes%heat_content_cond) .and. associated(flux_tmp%heat_content_cond)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_cond(i,j) = wt1*fluxes%heat_content_cond(i,j) + wt2*flux_tmp%heat_content_cond(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_lprec) .and. associated(flux_tmp%heat_content_lprec)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_lprec(i,j) = wt1*fluxes%heat_content_lprec(i,j) + wt2*flux_tmp%heat_content_lprec(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_fprec) .and. associated(flux_tmp%heat_content_fprec)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_fprec(i,j) = wt1*fluxes%heat_content_fprec(i,j) + wt2*flux_tmp%heat_content_fprec(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_icemelt) .and. associated(flux_tmp%heat_content_icemelt)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_icemelt(i,j) = wt1*fluxes%heat_content_icemelt(i,j) + wt2*flux_tmp%heat_content_icemelt(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_vprec) .and. associated(flux_tmp%heat_content_vprec)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_vprec(i,j) = wt1*fluxes%heat_content_vprec(i,j) + wt2*flux_tmp%heat_content_vprec(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_lrunoff) .and. associated(flux_tmp%heat_content_lrunoff)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_lrunoff(i,j) = wt1*fluxes%heat_content_lrunoff(i,j) + wt2*flux_tmp%heat_content_lrunoff(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_frunoff) .and. associated(flux_tmp%heat_content_frunoff)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_frunoff(i,j) = wt1*fluxes%heat_content_frunoff(i,j) + wt2*flux_tmp%heat_content_frunoff(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%heat_content_icemelt) .and. associated(flux_tmp%heat_content_icemelt)) then
    do j=js,je ; do i=is,ie
      fluxes%heat_content_icemelt(i,j) = wt1*fluxes%heat_content_icemelt(i,j) + wt2*flux_tmp%heat_content_icemelt(i,j)
    enddo ; enddo
  endif
 
  if (associated(fluxes%ustar_shelf) .and. associated(flux_tmp%ustar_shelf)) then
    do i=isd,ied ; do j=jsd,jed
      fluxes%ustar_shelf(i,j)  = flux_tmp%ustar_shelf(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%iceshelf_melt) .and. associated(flux_tmp%iceshelf_melt)) then
    do i=isd,ied ; do j=jsd,jed
      fluxes%iceshelf_melt(i,j)  = flux_tmp%iceshelf_melt(i,j)
    enddo ; enddo
  endif
  if (associated(fluxes%frac_shelf_h) .and. associated(flux_tmp%frac_shelf_h)) then
    do i=isd,ied ; do j=jsd,jed
      fluxes%frac_shelf_h(i,j)  = flux_tmp%frac_shelf_h(i,j)
    enddo ; enddo
  endif
 
  if (coupler_type_initialized(fluxes%tr_fluxes) .and. &
      coupler_type_initialized(flux_tmp%tr_fluxes)) &
    call coupler_type_increment_data(flux_tmp%tr_fluxes, fluxes%tr_fluxes, &
                              scale_factor=wt2, scale_prev=wt1)
 

References mom_error_handler::mom_error().

Referenced by forcing_accumulate().

Here is the call graph for this function:

Here is the caller graph for this function:

forcing_accumulate()

subroutine, public mom_forcing_type::forcing_accumulate	(	type(forcing), intent(in)	flux_tmp,
		type(mech_forcing), intent(in)	forces,
		type(forcing), intent(inout)	fluxes,
		type(ocean_grid_type), intent(inout)	G,
		real, intent(out)	wt2
	)

Accumulate the forcing over time steps, taking input from a mechanical forcing type and a temporary forcing-flux type.

Parameters

[in]	flux_tmp	A temporary structure with current thermodynamic forcing fields
[in]	forces	A structure with the driving mechanical forces
[in,out]	fluxes	A structure containing time-averaged thermodynamic forcing fields
[in,out]	g	The ocean's grid structure
[out]	wt2	The relative weight of the new fluxes

Definition at line 1882 of file MOM_forcing_type.F90.

  type(forcing),         intent(in)    :: flux_tmp !< A temporary structure with current
                                                 !!thermodynamic forcing fields
  type(mech_forcing),    intent(in)    :: forces !< A structure with the driving mechanical forces
  type(forcing),         intent(inout) :: fluxes !< A structure containing time-averaged
                                                 !! thermodynamic forcing fields
  type(ocean_grid_type), intent(inout) :: G      !< The ocean's grid structure
  real,                  intent(out)   :: wt2    !< The relative weight of the new fluxes
 
  ! This subroutine copies mechancal forcing from flux_tmp to fluxes and
  ! stores the time-weighted averages of the various buoyancy fluxes in fluxes,
  ! and increments the amount of time over which the buoyancy forcing should be
  ! applied, all via a call to fluxes accumulate.
 
  call fluxes_accumulate(flux_tmp, fluxes, g, wt2, forces)
 

References fluxes_accumulate().

Here is the call graph for this function:

forcing_diagnostics()

subroutine, public mom_forcing_type::forcing_diagnostics	(	type(forcing), intent(in)	fluxes,
		type(surface), intent(in)	sfc_state,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		type(time_type), intent(in)	time_end,
		type(diag_ctrl), intent(inout)	diag,
		type(forcing_diags), intent(inout)	handles
	)

Offer buoyancy forcing fields for diagnostics for those fields registered as part of register_forcing_type_diags.

Parameters

[in]	fluxes	A structure containing thermodynamic forcing fields
[in]	sfc_state	A structure containing fields that describe the surface state of the ocean.
[in]	g	grid type
[in]	us	A dimensional unit scaling type
[in]	time_end	The end time of the diagnostic interval.
[in,out]	diag	diagnostic regulator
[in,out]	handles	diagnostic ids

Definition at line 2238 of file MOM_forcing_type.F90.

  type(forcing),         intent(in)    :: fluxes    !< A structure containing thermodynamic forcing fields
  type(surface),         intent(in)    :: sfc_state !< A structure containing fields that
                                                    !! describe the surface state of the ocean.
  type(ocean_grid_type), intent(in)    :: G         !< grid type
  type(unit_scale_type), intent(in)    :: US        !< A dimensional unit scaling type
  type(time_type),       intent(in)    :: time_end  !< The end time of the diagnostic interval.
  type(diag_ctrl),       intent(inout) :: diag      !< diagnostic regulator
  type(forcing_diags),   intent(inout) :: handles   !< diagnostic ids
 
  ! local
  real, dimension(SZI_(G),SZJ_(G)) :: res
  real :: total_transport ! for diagnosing integrated boundary transport
  real :: ave_flux        ! for diagnosing averaged   boundary flux
  real :: C_p             ! seawater heat capacity (J/(deg K * kg))
  real :: RZ_T_conversion ! A combination of scaling factors for mass fluxes [kg T m-2 s-1 R-1 Z-1 ~> 1]
  real :: I_dt            ! inverse time step [s-1]
  real :: ppt2mks         ! conversion between ppt and mks
  integer :: i,j,is,ie,js,je
 
  call cpu_clock_begin(handles%id_clock_forcing)
 
  c_p     = fluxes%C_p
  rz_t_conversion = us%R_to_kg_m3*us%Z_to_m*us%s_to_T
  i_dt    = 1.0 / (us%T_to_s*fluxes%dt_buoy_accum)
  ppt2mks = 1e-3
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
 
  call enable_averages(fluxes%dt_buoy_accum, time_end, diag)
  ! if (query_averaging_enabled(diag)) then
 
    ! post the diagnostics for surface mass fluxes ==================================
 
    if (handles%id_prcme > 0 .or. handles%id_total_prcme > 0 .or. handles%id_prcme_ga > 0) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
        if (associated(fluxes%lprec))       res(i,j) = res(i,j) + rz_t_conversion*fluxes%lprec(i,j)
        if (associated(fluxes%fprec))       res(i,j) = res(i,j) + rz_t_conversion*fluxes%fprec(i,j)
        ! fluxes%cond is not needed because it is derived from %evap > 0
        if (associated(fluxes%evap))        res(i,j) = res(i,j) + rz_t_conversion*fluxes%evap(i,j)
        if (associated(fluxes%lrunoff))     res(i,j) = res(i,j) + rz_t_conversion*fluxes%lrunoff(i,j)
        if (associated(fluxes%frunoff))     res(i,j) = res(i,j) + rz_t_conversion*fluxes%frunoff(i,j)
        if (associated(fluxes%vprec))       res(i,j) = res(i,j) + rz_t_conversion*fluxes%vprec(i,j)
        if (associated(fluxes%seaice_melt)) res(i,j) = res(i,j) + rz_t_conversion*fluxes%seaice_melt(i,j)
      enddo ; enddo
      if (handles%id_prcme > 0) call post_data(handles%id_prcme, res, diag)
      if (handles%id_total_prcme > 0) then
        total_transport = global_area_integral(res, g)
        call post_data(handles%id_total_prcme, total_transport, diag)
      endif
      if (handles%id_prcme_ga > 0) then
        ave_flux = global_area_mean(res,g)
        call post_data(handles%id_prcme_ga, ave_flux, diag)
      endif
    endif
 
    if (handles%id_net_massout > 0 .or. handles%id_total_net_massout > 0) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
        if (associated(fluxes%lprec)) then
          if (fluxes%lprec(i,j) < 0.0) res(i,j) = res(i,j) + rz_t_conversion*fluxes%lprec(i,j)
        endif
        if (associated(fluxes%vprec)) then
          if (fluxes%vprec(i,j) < 0.0) res(i,j) = res(i,j) + rz_t_conversion*fluxes%vprec(i,j)
        endif
        if (associated(fluxes%evap)) then
          if (fluxes%evap(i,j) < 0.0) res(i,j) = res(i,j) + rz_t_conversion*fluxes%evap(i,j)
        endif
        if (associated(fluxes%seaice_melt)) then
          if (fluxes%seaice_melt(i,j) < 0.0) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%seaice_melt(i,j)
        endif
      enddo ; enddo
      if (handles%id_net_massout > 0) call post_data(handles%id_net_massout, res, diag)
      if (handles%id_total_net_massout > 0) then
        total_transport = global_area_integral(res,g)
        call post_data(handles%id_total_net_massout, total_transport, diag)
      endif
    endif
 
    if (handles%id_massout_flux > 0 .and. associated(fluxes%netMassOut)) &
      call post_data(handles%id_massout_flux,fluxes%netMassOut,diag)
 
    if (handles%id_net_massin > 0 .or. handles%id_total_net_massin > 0) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
 
        if (associated(fluxes%fprec)) &
          res(i,j) = res(i,j) + rz_t_conversion*fluxes%fprec(i,j)
        if (associated(fluxes%lrunoff)) &
          res(i,j) = res(i,j) + rz_t_conversion*fluxes%lrunoff(i,j)
        if (associated(fluxes%frunoff)) &
          res(i,j) = res(i,j) + rz_t_conversion*fluxes%frunoff(i,j)
 
        if (associated(fluxes%lprec)) then
          if (fluxes%lprec(i,j) > 0.0) res(i,j) = res(i,j) + rz_t_conversion*fluxes%lprec(i,j)
        endif
        if (associated(fluxes%vprec)) then
          if (fluxes%vprec(i,j) > 0.0) res(i,j) = res(i,j) + rz_t_conversion*fluxes%vprec(i,j)
        endif
        ! fluxes%cond is not needed because it is derived from %evap > 0
        if (associated(fluxes%evap)) then
          if (fluxes%evap(i,j) > 0.0) res(i,j) = res(i,j) + rz_t_conversion*fluxes%evap(i,j)
        endif
        if (associated(fluxes%seaice_melt)) then
          if (fluxes%seaice_melt(i,j) > 0.0) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%seaice_melt(i,j)
        endif
      enddo ; enddo
      if (handles%id_net_massin > 0) call post_data(handles%id_net_massin, res, diag)
      if (handles%id_total_net_massin > 0) then
        total_transport = global_area_integral(res,g)
        call post_data(handles%id_total_net_massin, total_transport, diag)
      endif
    endif
 
    if (handles%id_massin_flux > 0 .and. associated(fluxes%netMassIn)) &
      call post_data(handles%id_massin_flux,fluxes%netMassIn,diag)
 
    if ((handles%id_evap > 0) .and. associated(fluxes%evap)) &
      call post_data(handles%id_evap, fluxes%evap, diag)
    if ((handles%id_total_evap > 0) .and. associated(fluxes%evap)) then
      total_transport = global_area_integral(fluxes%evap, g, scale=rz_t_conversion)
      call post_data(handles%id_total_evap, total_transport, diag)
    endif
    if ((handles%id_evap_ga > 0) .and. associated(fluxes%evap)) then
      ave_flux = global_area_mean(fluxes%evap, g, scale=rz_t_conversion)
      call post_data(handles%id_evap_ga, ave_flux, diag)
    endif
 
    if (associated(fluxes%lprec) .and. associated(fluxes%fprec)) then
      do j=js,je ; do i=is,ie
        res(i,j) = rz_t_conversion* (fluxes%lprec(i,j) + fluxes%fprec(i,j))
      enddo ; enddo
      if (handles%id_precip > 0) call post_data(handles%id_precip, res, diag)
      if (handles%id_total_precip > 0) then
        total_transport = global_area_integral(res,g)
        call post_data(handles%id_total_precip, total_transport, diag)
      endif
      if (handles%id_precip_ga > 0) then
        ave_flux = global_area_mean(res,g)
        call post_data(handles%id_precip_ga, ave_flux, diag)
      endif
    endif
 
    if (associated(fluxes%lprec)) then
      if (handles%id_lprec > 0) call post_data(handles%id_lprec, fluxes%lprec, diag)
      if (handles%id_total_lprec > 0) then
        total_transport = global_area_integral(fluxes%lprec, g, scale=rz_t_conversion)
        call post_data(handles%id_total_lprec, total_transport, diag)
      endif
      if (handles%id_lprec_ga > 0) then
        ave_flux = global_area_mean(fluxes%lprec, g, scale=rz_t_conversion)
        call post_data(handles%id_lprec_ga, ave_flux, diag)
      endif
    endif
 
    if (associated(fluxes%fprec)) then
      if (handles%id_fprec > 0) call post_data(handles%id_fprec, fluxes%fprec, diag)
      if (handles%id_total_fprec > 0) then
        total_transport = global_area_integral(fluxes%fprec ,g, scale=rz_t_conversion)
        call post_data(handles%id_total_fprec, total_transport, diag)
      endif
      if (handles%id_fprec_ga > 0) then
        ave_flux = global_area_mean(fluxes%fprec, g, scale=rz_t_conversion)
        call post_data(handles%id_fprec_ga, ave_flux, diag)
      endif
    endif
 
    if (associated(fluxes%vprec)) then
      if (handles%id_vprec > 0) call post_data(handles%id_vprec, fluxes%vprec, diag)
      if (handles%id_total_vprec > 0) then
        total_transport = global_area_integral(fluxes%vprec, g, scale=rz_t_conversion)
        call post_data(handles%id_total_vprec, total_transport, diag)
      endif
      if (handles%id_vprec_ga > 0) then
        ave_flux = global_area_mean(fluxes%vprec, g, scale=rz_t_conversion)
        call post_data(handles%id_vprec_ga, ave_flux, diag)
      endif
    endif
 
    if (associated(fluxes%lrunoff)) then
    if (handles%id_lrunoff > 0) call post_data(handles%id_lrunoff, fluxes%lrunoff, diag)
      if (handles%id_total_lrunoff > 0) then
        total_transport = global_area_integral(fluxes%lrunoff, g, scale=rz_t_conversion)
        call post_data(handles%id_total_lrunoff, total_transport, diag)
      endif
    endif
 
    if (associated(fluxes%frunoff)) then
      if (handles%id_frunoff > 0) call post_data(handles%id_frunoff, fluxes%frunoff, diag)
      if (handles%id_total_frunoff > 0) then
        total_transport = global_area_integral(fluxes%frunoff, g, scale=rz_t_conversion)
        call post_data(handles%id_total_frunoff, total_transport, diag)
      endif
    endif
 
    if (associated(fluxes%seaice_melt)) then
      if (handles%id_seaice_melt > 0) call post_data(handles%id_seaice_melt, fluxes%seaice_melt, diag)
      if (handles%id_total_seaice_melt > 0) then
        total_transport = global_area_integral(fluxes%seaice_melt, g, scale=rz_t_conversion)
        call post_data(handles%id_total_seaice_melt, total_transport, diag)
      endif
    endif
 
    ! post diagnostics for boundary heat fluxes ====================================
 
    if ((handles%id_heat_content_lrunoff > 0) .and. associated(fluxes%heat_content_lrunoff))  &
      call post_data(handles%id_heat_content_lrunoff, fluxes%heat_content_lrunoff, diag)
    if ((handles%id_total_heat_content_lrunoff > 0) .and. associated(fluxes%heat_content_lrunoff)) then
      total_transport = global_area_integral(fluxes%heat_content_lrunoff, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_lrunoff, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_frunoff > 0) .and. associated(fluxes%heat_content_frunoff))  &
      call post_data(handles%id_heat_content_frunoff, fluxes%heat_content_frunoff, diag)
    if ((handles%id_total_heat_content_frunoff > 0) .and. associated(fluxes%heat_content_frunoff)) then
      total_transport = global_area_integral(fluxes%heat_content_frunoff, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_frunoff, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_lprec > 0) .and. associated(fluxes%heat_content_lprec))      &
      call post_data(handles%id_heat_content_lprec, fluxes%heat_content_lprec, diag)
    if ((handles%id_total_heat_content_lprec > 0) .and. associated(fluxes%heat_content_lprec)) then
      total_transport = global_area_integral(fluxes%heat_content_lprec, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_lprec, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_fprec > 0) .and. associated(fluxes%heat_content_fprec))      &
      call post_data(handles%id_heat_content_fprec, fluxes%heat_content_fprec, diag)
    if ((handles%id_total_heat_content_fprec > 0) .and. associated(fluxes%heat_content_fprec)) then
      total_transport = global_area_integral(fluxes%heat_content_fprec, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_fprec, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_icemelt > 0) .and. associated(fluxes%heat_content_icemelt))      &
      call post_data(handles%id_heat_content_icemelt, fluxes%heat_content_icemelt, diag)
    if ((handles%id_total_heat_content_icemelt > 0) .and. associated(fluxes%heat_content_icemelt)) then
      total_transport = global_area_integral(fluxes%heat_content_icemelt, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_icemelt, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_vprec > 0) .and. associated(fluxes%heat_content_vprec))      &
      call post_data(handles%id_heat_content_vprec, fluxes%heat_content_vprec, diag)
    if ((handles%id_total_heat_content_vprec > 0) .and. associated(fluxes%heat_content_vprec)) then
      total_transport = global_area_integral(fluxes%heat_content_vprec, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_vprec, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_cond > 0) .and. associated(fluxes%heat_content_cond))        &
      call post_data(handles%id_heat_content_cond, fluxes%heat_content_cond, diag)
    if ((handles%id_total_heat_content_cond > 0) .and. associated(fluxes%heat_content_cond)) then
      total_transport = global_area_integral(fluxes%heat_content_cond, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_cond, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_massout > 0) .and. associated(fluxes%heat_content_massout))  &
      call post_data(handles%id_heat_content_massout, fluxes%heat_content_massout, diag)
    if ((handles%id_total_heat_content_massout > 0) .and. associated(fluxes%heat_content_massout)) then
      total_transport = global_area_integral(fluxes%heat_content_massout,g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_massout, total_transport, diag)
    endif
 
    if ((handles%id_heat_content_massin > 0) .and. associated(fluxes%heat_content_massin))  &
      call post_data(handles%id_heat_content_massin, fluxes%heat_content_massin, diag)
    if ((handles%id_total_heat_content_massin > 0) .and. associated(fluxes%heat_content_massin)) then
      total_transport = global_area_integral(fluxes%heat_content_massin, g, scale=rz_t_conversion)
      call post_data(handles%id_total_heat_content_massin, total_transport, diag)
    endif
 
    if (handles%id_net_heat_coupler > 0 .or. handles%id_total_net_heat_coupler > 0 .or. &
        handles%id_net_heat_coupler_ga > 0. ) then
      do j=js,je ; do i=is,ie
      res(i,j) = 0.0
      if (associated(fluxes%LW))               res(i,j) = res(i,j) + fluxes%LW(i,j)
      if (associated(fluxes%latent))           res(i,j) = res(i,j) + fluxes%latent(i,j)
      if (associated(fluxes%sens))             res(i,j) = res(i,j) + fluxes%sens(i,j)
      if (associated(fluxes%SW))               res(i,j) = res(i,j) + fluxes%SW(i,j)
      if (associated(fluxes%seaice_melt_heat)) res(i,j) = res(i,j) + fluxes%seaice_melt_heat(i,j)
      enddo ; enddo
      if (handles%id_net_heat_coupler > 0) call post_data(handles%id_net_heat_coupler, res, diag)
      if (handles%id_total_net_heat_coupler > 0) then
        total_transport = global_area_integral(res,g)
        call post_data(handles%id_total_net_heat_coupler, total_transport, diag)
      endif
      if (handles%id_net_heat_coupler_ga > 0) then
        ave_flux = global_area_mean(res,g)
        call post_data(handles%id_net_heat_coupler_ga, ave_flux, diag)
      endif
    endif
 
    if (handles%id_net_heat_surface > 0 .or. handles%id_total_net_heat_surface > 0 .or. &
        handles%id_net_heat_surface_ga > 0. ) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
        if (associated(fluxes%LW))                   res(i,j) = res(i,j) + fluxes%LW(i,j)
        if (associated(fluxes%latent))               res(i,j) = res(i,j) + fluxes%latent(i,j)
        if (associated(fluxes%sens))                 res(i,j) = res(i,j) + fluxes%sens(i,j)
        if (associated(fluxes%SW))                   res(i,j) = res(i,j) + fluxes%SW(i,j)
        if (associated(fluxes%seaice_melt_heat))     res(i,j) = res(i,j) + fluxes%seaice_melt_heat(i,j)
        if (associated(sfc_state%frazil))            res(i,j) = res(i,j) + sfc_state%frazil(i,j) * i_dt
        !if (associated(sfc_state%TempXpme)) then
        !  res(i,j) = res(i,j) + sfc_state%TempXpme(i,j) * fluxes%C_p * I_dt
        !else
          if (associated(fluxes%heat_content_lrunoff)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_lrunoff(i,j)
          if (associated(fluxes%heat_content_frunoff)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_frunoff(i,j)
          if (associated(fluxes%heat_content_lprec)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_lprec(i,j)
          if (associated(fluxes%heat_content_fprec)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_fprec(i,j)
          if (associated(fluxes%heat_content_icemelt)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_icemelt(i,j)
          if (associated(fluxes%heat_content_vprec)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_vprec(i,j)
          if (associated(fluxes%heat_content_cond)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_cond(i,j)
          if (associated(fluxes%heat_content_massout)) &
            res(i,j) = res(i,j) + rz_t_conversion*fluxes%heat_content_massout(i,j)
        !endif
        if (associated(fluxes%heat_added)) res(i,j) = res(i,j) + fluxes%heat_added(i,j)
      enddo ; enddo
      if (handles%id_net_heat_surface > 0) call post_data(handles%id_net_heat_surface, res, diag)
 
      if (handles%id_total_net_heat_surface > 0) then
        total_transport = global_area_integral(res, g)
        call post_data(handles%id_total_net_heat_surface, total_transport, diag)
      endif
      if (handles%id_net_heat_surface_ga > 0) then
        ave_flux = global_area_mean(res, g)
        call post_data(handles%id_net_heat_surface_ga, ave_flux, diag)
      endif
    endif
 
    if (handles%id_heat_content_surfwater > 0 .or. handles%id_total_heat_content_surfwater > 0) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
      ! if (associated(sfc_state%TempXpme)) then
      !   res(i,j) = res(i,j) + sfc_state%TempXpme(i,j) * fluxes%C_p * I_dt
      ! else
          if (associated(fluxes%heat_content_lrunoff)) res(i,j) = res(i,j) + fluxes%heat_content_lrunoff(i,j)
          if (associated(fluxes%heat_content_frunoff)) res(i,j) = res(i,j) + fluxes%heat_content_frunoff(i,j)
          if (associated(fluxes%heat_content_lprec))   res(i,j) = res(i,j) + fluxes%heat_content_lprec(i,j)
          if (associated(fluxes%heat_content_icemelt)) res(i,j) = res(i,j) + fluxes%heat_content_icemelt(i,j)
          if (associated(fluxes%heat_content_fprec))   res(i,j) = res(i,j) + fluxes%heat_content_fprec(i,j)
          if (associated(fluxes%heat_content_vprec))   res(i,j) = res(i,j) + fluxes%heat_content_vprec(i,j)
          if (associated(fluxes%heat_content_cond))    res(i,j) = res(i,j) + fluxes%heat_content_cond(i,j)
          if (associated(fluxes%heat_content_massout)) res(i,j) = res(i,j) + fluxes%heat_content_massout(i,j)
      ! endif
      enddo ; enddo
      if (handles%id_heat_content_surfwater > 0) call post_data(handles%id_heat_content_surfwater, res, diag)
      if (handles%id_total_heat_content_surfwater > 0) then
        total_transport = global_area_integral(res, g, scale=rz_t_conversion)
        call post_data(handles%id_total_heat_content_surfwater, total_transport, diag)
      endif
    endif
 
    ! for OMIP, hfrunoffds = heat content of liquid plus frozen runoff
    if (handles%id_hfrunoffds > 0) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
        if (associated(fluxes%heat_content_lrunoff)) res(i,j) = res(i,j) + fluxes%heat_content_lrunoff(i,j)
        if (associated(fluxes%heat_content_frunoff)) res(i,j) = res(i,j) + fluxes%heat_content_frunoff(i,j)
      enddo ; enddo
      call post_data(handles%id_hfrunoffds, res, diag)
    endif
 
    ! for OMIP, hfrainds = heat content of lprec + fprec + cond
    if (handles%id_hfrainds > 0) then
      do j=js,je ; do i=is,ie
        res(i,j) = 0.0
        if (associated(fluxes%heat_content_lprec)) res(i,j) = res(i,j) + fluxes%heat_content_lprec(i,j)
        if (associated(fluxes%heat_content_fprec)) res(i,j) = res(i,j) + fluxes%heat_content_fprec(i,j)
        if (associated(fluxes%heat_content_cond)) res(i,j) = res(i,j) + fluxes%heat_content_cond(i,j)
      enddo ; enddo
      call post_data(handles%id_hfrainds, res, diag)
    endif
 
    if ((handles%id_LwLatSens > 0) .and. associated(fluxes%lw) .and. &
         associated(fluxes%latent) .and. associated(fluxes%sens)) then
      do j=js,je ; do i=is,ie
        res(i,j) = (fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j)
      enddo ; enddo
      call post_data(handles%id_LwLatSens, res, diag)
    endif
 
    if ((handles%id_total_LwLatSens > 0) .and. associated(fluxes%lw) .and. &
         associated(fluxes%latent) .and. associated(fluxes%sens)) then
      do j=js,je ; do i=is,ie
        res(i,j) = (fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j)
      enddo ; enddo
      total_transport = global_area_integral(res,g)
      call post_data(handles%id_total_LwLatSens, total_transport, diag)
    endif
 
    if ((handles%id_LwLatSens_ga > 0) .and. associated(fluxes%lw) .and. &
         associated(fluxes%latent) .and. associated(fluxes%sens)) then
      do j=js,je ; do i=is,ie
        res(i,j) = (fluxes%lw(i,j) + fluxes%latent(i,j)) + fluxes%sens(i,j)
      enddo ; enddo
      ave_flux = global_area_mean(res,g)
      call post_data(handles%id_LwLatSens_ga, ave_flux, diag)
    endif
 
    if ((handles%id_sw > 0) .and. associated(fluxes%sw)) then
      call post_data(handles%id_sw, fluxes%sw, diag)
    endif
    if ((handles%id_sw_vis > 0) .and. associated(fluxes%sw_vis_dir) .and. &
        associated(fluxes%sw_vis_dif)) then
      call post_data(handles%id_sw_vis, fluxes%sw_vis_dir+fluxes%sw_vis_dif, diag)
    endif
    if ((handles%id_sw_nir > 0) .and. associated(fluxes%sw_nir_dir) .and. &
        associated(fluxes%sw_nir_dif)) then
      call post_data(handles%id_sw_nir, fluxes%sw_nir_dir+fluxes%sw_nir_dif, diag)
    endif
    if ((handles%id_total_sw > 0) .and. associated(fluxes%sw)) then
      total_transport = global_area_integral(fluxes%sw,g)
      call post_data(handles%id_total_sw, total_transport, diag)
    endif
    if ((handles%id_sw_ga > 0) .and. associated(fluxes%sw)) then
      ave_flux = global_area_mean(fluxes%sw,g)
      call post_data(handles%id_sw_ga, ave_flux, diag)
    endif
 
    if ((handles%id_lw > 0) .and. associated(fluxes%lw)) then
      call post_data(handles%id_lw, fluxes%lw, diag)
    endif
    if ((handles%id_total_lw > 0) .and. associated(fluxes%lw)) then
      total_transport = global_area_integral(fluxes%lw,g)
      call post_data(handles%id_total_lw, total_transport, diag)
    endif
    if ((handles%id_lw_ga > 0) .and. associated(fluxes%lw)) then
      ave_flux = global_area_mean(fluxes%lw,g)
      call post_data(handles%id_lw_ga, ave_flux, diag)
    endif
 
    if ((handles%id_lat > 0) .and. associated(fluxes%latent)) then
      call post_data(handles%id_lat, fluxes%latent, diag)
    endif
    if ((handles%id_total_lat > 0) .and. associated(fluxes%latent)) then
      total_transport = global_area_integral(fluxes%latent,g)
      call post_data(handles%id_total_lat, total_transport, diag)
    endif
    if ((handles%id_lat_ga > 0) .and. associated(fluxes%latent)) then
      ave_flux = global_area_mean(fluxes%latent,g)
      call post_data(handles%id_lat_ga, ave_flux, diag)
    endif
 
    if ((handles%id_lat_evap > 0) .and. associated(fluxes%latent_evap_diag)) then
      call post_data(handles%id_lat_evap, fluxes%latent_evap_diag, diag)
    endif
    if ((handles%id_total_lat_evap > 0) .and. associated(fluxes%latent_evap_diag)) then
      total_transport = global_area_integral(fluxes%latent_evap_diag,g)
      call post_data(handles%id_total_lat_evap, total_transport, diag)
    endif
 
    if ((handles%id_lat_fprec > 0) .and. associated(fluxes%latent_fprec_diag)) then
      call post_data(handles%id_lat_fprec, fluxes%latent_fprec_diag, diag)
    endif
    if ((handles%id_total_lat_fprec > 0) .and. associated(fluxes%latent_fprec_diag)) then
      total_transport = global_area_integral(fluxes%latent_fprec_diag,g)
      call post_data(handles%id_total_lat_fprec, total_transport, diag)
    endif
 
    if ((handles%id_lat_frunoff > 0) .and. associated(fluxes%latent_frunoff_diag)) then
      call post_data(handles%id_lat_frunoff, fluxes%latent_frunoff_diag, diag)
    endif
    if (handles%id_total_lat_frunoff > 0 .and. associated(fluxes%latent_frunoff_diag)) then
      total_transport = global_area_integral(fluxes%latent_frunoff_diag,g)
      call post_data(handles%id_total_lat_frunoff, total_transport, diag)
    endif
 
    if ((handles%id_sens > 0) .and. associated(fluxes%sens)) then
      call post_data(handles%id_sens, fluxes%sens, diag)
    endif
 
    if ((handles%id_seaice_melt_heat > 0) .and. associated(fluxes%seaice_melt_heat)) then
      call post_data(handles%id_seaice_melt_heat, fluxes%seaice_melt_heat, diag)
    endif
 
    if ((handles%id_total_seaice_melt_heat > 0) .and. associated(fluxes%seaice_melt_heat)) then
      total_transport = global_area_integral(fluxes%seaice_melt_heat,g)
      call post_data(handles%id_total_seaice_melt_heat, total_transport, diag)
    endif
 
    if ((handles%id_total_sens > 0) .and. associated(fluxes%sens)) then
      total_transport = global_area_integral(fluxes%sens,g)
      call post_data(handles%id_total_sens, total_transport, diag)
    endif
    if ((handles%id_sens_ga > 0) .and. associated(fluxes%sens)) then
      ave_flux = global_area_mean(fluxes%sens,g)
      call post_data(handles%id_sens_ga, ave_flux, diag)
    endif
 
    if ((handles%id_heat_added > 0) .and. associated(fluxes%heat_added)) then
      call post_data(handles%id_heat_added, fluxes%heat_added, diag)
    endif
 
    if ((handles%id_total_heat_added > 0) .and. associated(fluxes%heat_added)) then
      total_transport = global_area_integral(fluxes%heat_added,g)
      call post_data(handles%id_total_heat_added, total_transport, diag)
    endif
 
 
    ! post the diagnostics for boundary salt fluxes ==========================
 
    if ((handles%id_saltflux > 0) .and. associated(fluxes%salt_flux)) &
      call post_data(handles%id_saltflux, fluxes%salt_flux, diag)
    if ((handles%id_total_saltflux > 0) .and. associated(fluxes%salt_flux)) then
      total_transport = ppt2mks*global_area_integral(fluxes%salt_flux, g, scale=rz_t_conversion)
      call post_data(handles%id_total_saltflux, total_transport, diag)
    endif
 
    if ((handles%id_saltFluxAdded > 0) .and. associated(fluxes%salt_flux_added)) &
      call post_data(handles%id_saltFluxAdded, fluxes%salt_flux_added, diag)
    if ((handles%id_total_saltFluxAdded > 0) .and. associated(fluxes%salt_flux_added)) then
      total_transport = ppt2mks*global_area_integral(fluxes%salt_flux_added, g, scale=rz_t_conversion)
      call post_data(handles%id_total_saltFluxAdded, total_transport, diag)
    endif
 
    if (handles%id_saltFluxIn > 0 .and. associated(fluxes%salt_flux_in)) &
      call post_data(handles%id_saltFluxIn, fluxes%salt_flux_in, diag)
    if ((handles%id_total_saltFluxIn > 0) .and. associated(fluxes%salt_flux_in)) then
      total_transport = ppt2mks*global_area_integral(fluxes%salt_flux_in, g, scale=rz_t_conversion)
      call post_data(handles%id_total_saltFluxIn, total_transport, diag)
    endif
 
    if (handles%id_saltFluxGlobalAdj > 0)                                            &
      call post_data(handles%id_saltFluxGlobalAdj, fluxes%saltFluxGlobalAdj, diag)
    if (handles%id_vPrecGlobalAdj > 0)                                               &
      call post_data(handles%id_vPrecGlobalAdj, fluxes%vPrecGlobalAdj, diag)
    if (handles%id_netFWGlobalAdj > 0)                                               &
      call post_data(handles%id_netFWGlobalAdj, fluxes%netFWGlobalAdj, diag)
    if (handles%id_saltFluxGlobalScl > 0)                                            &
      call post_data(handles%id_saltFluxGlobalScl, fluxes%saltFluxGlobalScl, diag)
    if (handles%id_vPrecGlobalScl > 0)                                               &
      call post_data(handles%id_vPrecGlobalScl, fluxes%vPrecGlobalScl, diag)
    if (handles%id_netFWGlobalScl > 0)                                               &
      call post_data(handles%id_netFWGlobalScl, fluxes%netFWGlobalScl, diag)
 
 
    ! remaining boundary terms ==================================================
 
    if ((handles%id_psurf > 0) .and. associated(fluxes%p_surf))                      &
      call post_data(handles%id_psurf, fluxes%p_surf, diag)
 
    if ((handles%id_TKE_tidal > 0) .and. associated(fluxes%TKE_tidal))               &
      call post_data(handles%id_TKE_tidal, fluxes%TKE_tidal, diag)
 
    if ((handles%id_buoy > 0) .and. associated(fluxes%buoy))                         &
      call post_data(handles%id_buoy, fluxes%buoy, diag)
 
    if ((handles%id_ustar > 0) .and. associated(fluxes%ustar)) &
      call post_data(handles%id_ustar, fluxes%ustar, diag)
 
    if ((handles%id_ustar_berg > 0) .and. associated(fluxes%ustar_berg)) &
      call post_data(handles%id_ustar_berg, fluxes%ustar_berg, diag)
 
    if ((handles%id_frac_ice_cover > 0) .and. associated(fluxes%frac_shelf_h)) &
      call post_data(handles%id_frac_ice_cover, fluxes%frac_shelf_h, diag)
 
    if ((handles%id_ustar_ice_cover > 0) .and. associated(fluxes%ustar_shelf)) &
      call post_data(handles%id_ustar_ice_cover, fluxes%ustar_shelf, diag)
 
  ! endif  ! query_averaging_enabled
  call disable_averaging(diag)
 
  call cpu_clock_end(handles%id_clock_forcing)

References mom_diag_mediator::disable_averaging(), mom_diag_mediator::enable_averages(), mom_spatial_means::global_area_integral(), and mom_spatial_means::global_area_mean().

Referenced by mom_main(), mom_ocean_model_mct::update_ocean_model(), and mom_ocean_model_nuopc::update_ocean_model().

Here is the call graph for this function:

Here is the caller graph for this function:

forcing_singlepointprint()

subroutine, public mom_forcing_type::forcing_singlepointprint	(	type(forcing), intent(in)	fluxes,
		type(ocean_grid_type), intent(in)	G,
		integer, intent(in)	i,
		integer, intent(in)	j,
		character(len=*), intent(in)	mesg
	)

Write out values of the fluxes arrays at the i,j location. This is a debugging tool.

Parameters

[in]	fluxes	A structure containing thermodynamic forcing fields
[in]	g	Grid type
[in]	mesg	Message
[in]	i	i-index
[in]	j	j-index

Definition at line 1161 of file MOM_forcing_type.F90.

  type(forcing),         intent(in) :: fluxes !< A structure containing thermodynamic forcing fields
  type(ocean_grid_type), intent(in) :: G      !< Grid type
  character(len=*),      intent(in) :: mesg   !< Message
  integer,               intent(in) :: i      !< i-index
  integer,               intent(in) :: j      !< j-index
 
  write(0,'(2a)') 'MOM_forcing_type, forcing_SinglePointPrint: Called from ',mesg
  write(0,'(a,2es15.3)') 'MOM_forcing_type, forcing_SinglePointPrint: lon,lat = ',g%geoLonT(i,j),g%geoLatT(i,j)
  call locmsg(fluxes%ustar,'ustar')
  call locmsg(fluxes%buoy,'buoy')
  call locmsg(fluxes%sw,'sw')
  call locmsg(fluxes%sw_vis_dir,'sw_vis_dir')
  call locmsg(fluxes%sw_vis_dif,'sw_vis_dif')
  call locmsg(fluxes%sw_nir_dir,'sw_nir_dir')
  call locmsg(fluxes%sw_nir_dif,'sw_nir_dif')
  call locmsg(fluxes%lw,'lw')
  call locmsg(fluxes%latent,'latent')
  call locmsg(fluxes%latent_evap_diag,'latent_evap_diag')
  call locmsg(fluxes%latent_fprec_diag,'latent_fprec_diag')
  call locmsg(fluxes%latent_frunoff_diag,'latent_frunoff_diag')
  call locmsg(fluxes%sens,'sens')
  call locmsg(fluxes%evap,'evap')
  call locmsg(fluxes%lprec,'lprec')
  call locmsg(fluxes%fprec,'fprec')
  call locmsg(fluxes%vprec,'vprec')
  call locmsg(fluxes%seaice_melt,'seaice_melt')
  call locmsg(fluxes%seaice_melt_heat,'seaice_melt_heat')
  call locmsg(fluxes%p_surf,'p_surf')
  call locmsg(fluxes%salt_flux,'salt_flux')
  call locmsg(fluxes%TKE_tidal,'TKE_tidal')
  call locmsg(fluxes%ustar_tidal,'ustar_tidal')
  call locmsg(fluxes%lrunoff,'lrunoff')
  call locmsg(fluxes%frunoff,'frunoff')
  call locmsg(fluxes%heat_content_lrunoff,'heat_content_lrunoff')
  call locmsg(fluxes%heat_content_frunoff,'heat_content_frunoff')
  call locmsg(fluxes%heat_content_lprec,'heat_content_lprec')
  call locmsg(fluxes%heat_content_fprec,'heat_content_fprec')
  call locmsg(fluxes%heat_content_icemelt,'heat_content_icemelt')
  call locmsg(fluxes%heat_content_vprec,'heat_content_vprec')
  call locmsg(fluxes%heat_content_cond,'heat_content_cond')
  call locmsg(fluxes%heat_content_cond,'heat_content_massout')
 
  contains
  !> Format and write a message depending on associated state of array
  subroutine locmsg(array,aname)
    real, dimension(:,:), pointer :: array !< Array to write element from
    character(len=*)              :: aname !< Name of array
 
    if (associated(array)) then
      write(0,'(3a,es15.3)') 'MOM_forcing_type, forcing_SinglePointPrint: ',trim(aname),' = ',array(i,j)
    else
      write(0,'(4a)') 'MOM_forcing_type, forcing_SinglePointPrint: ',trim(aname),' is not associated.'
    endif
  end subroutine locmsg
 

References locmsg().

Referenced by mom_diabatic_aux::applyboundaryfluxesinout().

Here is the call graph for this function:

Here is the caller graph for this function:

get_net_mass_forcing()

subroutine, public mom_forcing_type::get_net_mass_forcing	(	type(forcing), intent(in)	fluxes,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(out)	net_mass_src
	)

This subroutine calculates determines the net mass source to the ocean from a (thermodynamic) forcing type and stores it in a provided array.

Parameters

[in]	fluxes	A structure containing thermodynamic forcing fields
[in]	g	The ocean grid type
[in]	us	A dimensional unit scaling type
[out]	net_mass_src	The net mass flux of water into the ocean [kg m-2 s-1].

Definition at line 2142 of file MOM_forcing_type.F90.

  type(forcing),                    intent(in)  :: fluxes !< A structure containing thermodynamic forcing fields
  type(ocean_grid_type),            intent(in)  :: G      !< The ocean grid type
  type(unit_scale_type),            intent(in)  :: US     !< A dimensional unit scaling type
  real, dimension(SZI_(G),SZJ_(G)), intent(out) :: net_mass_src !< The net mass flux of water into the ocean
                                                          !! [kg m-2 s-1].
 
  real :: RZ_T_conversion ! A combination of scaling factors for mass fluxes [kg T m-2 s-1 R-1 Z-1 ~> 1]
  integer :: i, j, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
 
  rz_t_conversion = us%R_to_kg_m3*us%Z_to_m*us%s_to_T
 
  net_mass_src(:,:) = 0.0
  if (associated(fluxes%lprec)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%lprec(i,j)
  enddo ; enddo ; endif
  if (associated(fluxes%fprec)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%fprec(i,j)
  enddo ; enddo ; endif
  if (associated(fluxes%vprec)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%vprec(i,j)
  enddo ; enddo ; endif
  if (associated(fluxes%lrunoff)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%lrunoff(i,j)
  enddo ; enddo ; endif
  if (associated(fluxes%frunoff)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%frunoff(i,j)
  enddo ; enddo ; endif
  if (associated(fluxes%evap)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%evap(i,j)
  enddo ; enddo ; endif
  if (associated(fluxes%seaice_melt)) then ; do j=js,je ; do i=is,ie
    net_mass_src(i,j) = net_mass_src(i,j) + rz_t_conversion*fluxes%seaice_melt(i,j)
  enddo ; enddo ; endif
 

Referenced by set_net_mass_forcing().

Here is the caller graph for this function:

mech_forcing_diags()

subroutine, public mom_forcing_type::mech_forcing_diags	(	type(mech_forcing), intent(in)	forces,
		real, intent(in)	dt,
		type(ocean_grid_type), intent(in)	G,
		type(time_type), intent(in)	time_end,
		type(diag_ctrl), intent(inout)	diag,
		type(forcing_diags), intent(inout)	handles
	)

Offer mechanical forcing fields for diagnostics for those fields registered as part of register_forcing_type_diags.

Parameters

[in]	forces	A structure with the driving mechanical forces
[in]	dt	time step for the forcing [s]
[in]	g	grid type
[in]	time_end	The end time of the diagnostic interval.
[in,out]	diag	diagnostic type
[in,out]	handles	diagnostic id for diag_manager

Definition at line 2201 of file MOM_forcing_type.F90.

  type(mech_forcing),    intent(in)    :: forces   !< A structure with the driving mechanical forces
  real,                  intent(in)    :: dt       !< time step for the forcing [s]
  type(ocean_grid_type), intent(in)    :: G        !< grid type
  type(time_type),       intent(in)    :: time_end !< The end time of the diagnostic interval.
  type(diag_ctrl),       intent(inout) :: diag     !< diagnostic type
  type(forcing_diags),   intent(inout) :: handles  !< diagnostic id for diag_manager
 
  integer :: i,j,is,ie,js,je
 
  call cpu_clock_begin(handles%id_clock_forcing)
 
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  call enable_averaging(dt, time_end, diag)
  ! if (query_averaging_enabled(diag)) then
 
    if ((handles%id_taux > 0) .and. associated(forces%taux)) &
      call post_data(handles%id_taux, forces%taux, diag)
 
    if ((handles%id_tauy > 0) .and. associated(forces%tauy)) &
      call post_data(handles%id_tauy, forces%tauy, diag)
 
    if ((handles%id_mass_berg > 0) .and. associated(forces%mass_berg)) &
      call post_data(handles%id_mass_berg, forces%mass_berg, diag)
 
    if ((handles%id_area_berg > 0) .and. associated(forces%area_berg)) &
      call post_data(handles%id_area_berg, forces%area_berg, diag)
 
  ! endif
 
  call disable_averaging(diag)
  call cpu_clock_end(handles%id_clock_forcing)

References mom_diag_mediator::disable_averaging(), and mom_diag_mediator::enable_averaging().

Referenced by mom_main(), mom_ocean_model_mct::update_ocean_model(), and mom_ocean_model_nuopc::update_ocean_model().

Here is the call graph for this function:

Here is the caller graph for this function:

mech_forcing_singlepointprint()

subroutine mom_forcing_type::mech_forcing_singlepointprint ( type(mech_forcing), intent(in)  forces, type(ocean_grid_type), intent(in)  G, integer, intent(in)  i, integer, intent(in)  j, character(len=*), intent(in)  mesg  )

private

Write out values of the mechanical forcing arrays at the i,j location. This is a debugging tool.

Parameters

[in]	forces	A structure with the driving mechanical forces
[in]	g	Grid type
[in]	mesg	Message
[in]	i	i-index
[in]	j	j-index

Definition at line 1133 of file MOM_forcing_type.F90.

  type(mech_forcing),    intent(in) :: forces !< A structure with the driving mechanical forces
  type(ocean_grid_type), intent(in) :: G      !< Grid type
  character(len=*),      intent(in) :: mesg   !< Message
  integer,               intent(in) :: i      !< i-index
  integer,               intent(in) :: j      !< j-index
 
  write(0,'(2a)') 'MOM_forcing_type, forcing_SinglePointPrint: Called from ',mesg
  write(0,'(a,2es15.3)') 'MOM_forcing_type, forcing_SinglePointPrint: lon,lat = ',g%geoLonT(i,j),g%geoLatT(i,j)
  call locmsg(forces%taux,'taux')
  call locmsg(forces%tauy,'tauy')
 
  contains
  !> Format and write a message depending on associated state of array
  subroutine locmsg(array,aname)
    real, dimension(:,:), pointer :: array !< Array to write element from
    character(len=*)              :: aname !< Name of array
 
    if (associated(array)) then
      write(0,'(3a,es15.3)') 'MOM_forcing_type, mech_forcing_SinglePointPrint: ',trim(aname),' = ',array(i,j)
    else
      write(0,'(4a)') 'MOM_forcing_type, mech_forcing_SinglePointPrint: ',trim(aname),' is not associated.'
    endif
  end subroutine locmsg
 

References locmsg().

Here is the call graph for this function:

mom_forcing_chksum()

subroutine, public mom_forcing_type::mom_forcing_chksum	(	character(len=*), intent(in)	mesg,
		type(forcing), intent(in)	fluxes,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		integer, intent(in), optional	haloshift
	)

Write out chksums for thermodynamic fluxes.

Parameters

[in]	mesg	message
[in]	fluxes	A structure containing thermodynamic forcing fields
[in]	g	grid type
[in]	us	A dimensional unit scaling type
[in]	haloshift	shift in halo

Definition at line 1012 of file MOM_forcing_type.F90.

  character(len=*),        intent(in) :: mesg      !< message
  type(forcing),           intent(in) :: fluxes    !< A structure containing thermodynamic forcing fields
  type(ocean_grid_type),   intent(in) :: G         !< grid type
  type(unit_scale_type),   intent(in) :: US        !< A dimensional unit scaling type
  integer, optional,       intent(in) :: haloshift !< shift in halo
 
  real :: RZ_T_conversion ! A combination of scaling factors for mass fluxes [kg T m-2 s-1 R-1 Z-1 ~> 1]
  integer :: is, ie, js, je, nz, hshift
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
 
  hshift = 1 ; if (present(haloshift)) hshift = haloshift
  rz_t_conversion = us%R_to_kg_m3*us%Z_to_m*us%s_to_T
 
  ! Note that for the chksum calls to be useful for reproducing across PE
  ! counts, there must be no redundant points, so all variables use is..ie
  ! and js...je as their extent.
  if (associated(fluxes%ustar)) &
    call hchksum(fluxes%ustar, mesg//" fluxes%ustar",g%HI, haloshift=hshift, scale=us%Z_to_m*us%s_to_T)
  if (associated(fluxes%buoy)) &
    call hchksum(fluxes%buoy, mesg//" fluxes%buoy ",g%HI, haloshift=hshift, scale=us%L_to_m**2*us%s_to_T**3)
  if (associated(fluxes%sw)) &
    call hchksum(fluxes%sw, mesg//" fluxes%sw",g%HI,haloshift=hshift)
  if (associated(fluxes%sw_vis_dir)) &
    call hchksum(fluxes%sw_vis_dir, mesg//" fluxes%sw_vis_dir",g%HI,haloshift=hshift)
  if (associated(fluxes%sw_vis_dif)) &
    call hchksum(fluxes%sw_vis_dif, mesg//" fluxes%sw_vis_dif",g%HI,haloshift=hshift)
  if (associated(fluxes%sw_nir_dir)) &
    call hchksum(fluxes%sw_nir_dir, mesg//" fluxes%sw_nir_dir",g%HI,haloshift=hshift)
  if (associated(fluxes%sw_nir_dif)) &
    call hchksum(fluxes%sw_nir_dif, mesg//" fluxes%sw_nir_dif",g%HI,haloshift=hshift)
  if (associated(fluxes%lw)) &
    call hchksum(fluxes%lw, mesg//" fluxes%lw",g%HI,haloshift=hshift)
  if (associated(fluxes%latent)) &
    call hchksum(fluxes%latent, mesg//" fluxes%latent",g%HI,haloshift=hshift)
  if (associated(fluxes%latent_evap_diag)) &
    call hchksum(fluxes%latent_evap_diag, mesg//" fluxes%latent_evap_diag",g%HI,haloshift=hshift)
  if (associated(fluxes%latent_fprec_diag)) &
    call hchksum(fluxes%latent_fprec_diag, mesg//" fluxes%latent_fprec_diag",g%HI,haloshift=hshift)
  if (associated(fluxes%latent_frunoff_diag)) &
    call hchksum(fluxes%latent_frunoff_diag, mesg//" fluxes%latent_frunoff_diag",g%HI,haloshift=hshift)
  if (associated(fluxes%sens)) &
    call hchksum(fluxes%sens, mesg//" fluxes%sens",g%HI,haloshift=hshift)
  if (associated(fluxes%evap)) &
    call hchksum(fluxes%evap, mesg//" fluxes%evap",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%lprec)) &
    call hchksum(fluxes%lprec, mesg//" fluxes%lprec",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%fprec)) &
    call hchksum(fluxes%fprec, mesg//" fluxes%fprec",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%vprec)) &
    call hchksum(fluxes%vprec, mesg//" fluxes%vprec",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%seaice_melt)) &
    call hchksum(fluxes%seaice_melt, mesg//" fluxes%seaice_melt",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%seaice_melt_heat)) &
    call hchksum(fluxes%seaice_melt_heat, mesg//" fluxes%seaice_melt_heat",g%HI,haloshift=hshift)
  if (associated(fluxes%p_surf)) &
    call hchksum(fluxes%p_surf, mesg//" fluxes%p_surf",g%HI,haloshift=hshift)
  if (associated(fluxes%salt_flux)) &
    call hchksum(fluxes%salt_flux, mesg//" fluxes%salt_flux",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%TKE_tidal)) &
    call hchksum(fluxes%TKE_tidal, mesg//" fluxes%TKE_tidal",g%HI,haloshift=hshift, &
                 scale=us%R_to_kg_m3**3*us%Z_to_m**3*us%s_to_T)
  if (associated(fluxes%ustar_tidal)) &
    call hchksum(fluxes%ustar_tidal, mesg//" fluxes%ustar_tidal",g%HI,haloshift=hshift, scale=us%Z_to_m*us%s_to_T)
  if (associated(fluxes%lrunoff)) &
    call hchksum(fluxes%lrunoff, mesg//" fluxes%lrunoff",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%frunoff)) &
    call hchksum(fluxes%frunoff, mesg//" fluxes%frunoff",g%HI,haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_lrunoff)) &
    call hchksum(fluxes%heat_content_lrunoff, mesg//" fluxes%heat_content_lrunoff", g%HI, &
                 haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_frunoff)) &
    call hchksum(fluxes%heat_content_frunoff, mesg//" fluxes%heat_content_frunoff", g%HI, &
                 haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_lprec)) &
    call hchksum(fluxes%heat_content_lprec, mesg//" fluxes%heat_content_lprec", g%HI,  &
                 haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_fprec)) &
    call hchksum(fluxes%heat_content_fprec, mesg//" fluxes%heat_content_fprec", g%HI, &
                 haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_icemelt)) &
    call hchksum(fluxes%heat_content_icemelt, mesg//" fluxes%heat_content_icemelt", g%HI, &
                 haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_cond)) &
    call hchksum(fluxes%heat_content_cond, mesg//" fluxes%heat_content_cond", g%HI, &
                 haloshift=hshift, scale=rz_t_conversion)
  if (associated(fluxes%heat_content_massout)) &
    call hchksum(fluxes%heat_content_massout, mesg//" fluxes%heat_content_massout", g%HI, &
                 haloshift=hshift, scale=rz_t_conversion)

Referenced by mom_main(), and mom::step_mom_thermo().

Here is the caller graph for this function:

mom_mech_forcing_chksum()

subroutine, public mom_forcing_type::mom_mech_forcing_chksum	(	character(len=*), intent(in)	mesg,
		type(mech_forcing), intent(in)	forces,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		integer, intent(in), optional	haloshift
	)

Write out chksums for the driving mechanical forces.

Parameters

[in]	mesg	message
[in]	forces	A structure with the driving mechanical forces
[in]	g	grid type
[in]	us	A dimensional unit scaling type
[in]	haloshift	shift in halo

Definition at line 1104 of file MOM_forcing_type.F90.

  character(len=*),        intent(in) :: mesg      !< message
  type(mech_forcing),      intent(in) :: forces    !< A structure with the driving mechanical forces
  type(ocean_grid_type),   intent(in) :: G         !< grid type
  type(unit_scale_type),   intent(in) :: US        !< A dimensional unit scaling type
  integer, optional,       intent(in) :: haloshift !< shift in halo
 
  integer :: is, ie, js, je, nz, hshift
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
 
  hshift=1; if (present(haloshift)) hshift=haloshift
 
  ! Note that for the chksum calls to be useful for reproducing across PE
  ! counts, there must be no redundant points, so all variables use is..ie
  ! and js...je as their extent.
  if (associated(forces%taux) .and. associated(forces%tauy)) &
    call uvchksum(mesg//" forces%tau[xy]", forces%taux, forces%tauy, g%HI, &
                  haloshift=hshift, symmetric=.true., scale=us%R_to_kg_m3*us%L_T_to_m_s**2*us%Z_to_L)
  if (associated(forces%p_surf)) &
    call hchksum(forces%p_surf, mesg//" forces%p_surf",g%HI,haloshift=hshift)
  if (associated(forces%ustar)) &
    call hchksum(forces%ustar, mesg//" forces%ustar",g%HI,haloshift=hshift, scale=us%Z_to_m*us%s_to_T)
  if (associated(forces%rigidity_ice_u) .and. associated(forces%rigidity_ice_v)) &
    call uvchksum(mesg//" forces%rigidity_ice_[uv]", forces%rigidity_ice_u, &
                  forces%rigidity_ice_v, g%HI, haloshift=hshift, symmetric=.true.)
 

Referenced by mom_main(), and mom::step_mom().

Here is the caller graph for this function:

myalloc()

subroutine mom_forcing_type::myalloc ( real, dimension(:,:), pointer  array, integer, intent(in)  is, integer, intent(in)  ie, integer, intent(in)  js, integer, intent(in)  je, logical, intent(in), optional  flag  )

private

Allocates and zeroes-out array.

Parameters

	array	Array to be allocated
[in]	is	Start i-index
[in]	ie	End i-index
[in]	js	Start j-index
[in]	je	End j-index
[in]	flag	Flag to indicate to allocate

Definition at line 2917 of file MOM_forcing_type.F90.

  real, dimension(:,:), pointer :: array !< Array to be allocated
  integer,           intent(in) :: is !< Start i-index
  integer,           intent(in) :: ie !< End i-index
  integer,           intent(in) :: js !< Start j-index
  integer,           intent(in) :: je !< End j-index
  logical, optional, intent(in) :: flag !< Flag to indicate to allocate
 
  if (present(flag)) then ; if (flag) then ; if (.not.associated(array)) then
    allocate(array(is:ie,js:je)) ; array(is:ie,js:je) = 0.0
  endif ; endif ; endif

Referenced by allocate_forcing_type(), and allocate_mech_forcing().

Here is the caller graph for this function:

register_forcing_type_diags()

subroutine, public mom_forcing_type::register_forcing_type_diags	(	type(time_type), intent(in)	Time,
		type(diag_ctrl), intent(inout)	diag,
		type(unit_scale_type), intent(in)	US,
		logical, intent(in)	use_temperature,
		type(forcing_diags), intent(inout)	handles,
		logical, intent(in), optional	use_berg_fluxes
	)

Register members of the forcing type for diagnostics.

Parameters

[in]	time	time type
[in,out]	diag	diagnostic control type
[in]	us	A dimensional unit scaling type
[in]	use_temperature	True if T/S are in use
[in,out]	handles	handles for diagnostics
[in]	use_berg_fluxes	If true, allow iceberg flux diagnostics

Definition at line 1221 of file MOM_forcing_type.F90.

  type(time_type),     intent(in)    :: Time            !< time type
  type(diag_ctrl),     intent(inout) :: diag            !< diagnostic control type
  type(unit_scale_type), intent(in)  :: US              !< A dimensional unit scaling type
  logical,             intent(in)    :: use_temperature !< True if T/S are in use
  type(forcing_diags), intent(inout) :: handles         !< handles for diagnostics
  logical, optional,   intent(in)    :: use_berg_fluxes !< If true, allow iceberg flux diagnostics
 
  ! Clock for forcing diagnostics
  handles%id_clock_forcing=cpu_clock_id('(Ocean forcing diagnostics)', grain=clock_routine)
 
 
  handles%id_taux = register_diag_field('ocean_model', 'taux', diag%axesCu1, time,  &
        'Zonal surface stress from ocean interactions with atmos and ice', &
        'Pa', conversion=us%R_to_kg_m3*us%L_T_to_m_s**2*us%Z_to_L, &
        standard_name='surface_downward_x_stress', cmor_field_name='tauuo',         &
        cmor_units='N m-2', cmor_long_name='Surface Downward X Stress',             &
        cmor_standard_name='surface_downward_x_stress')
 
  handles%id_tauy = register_diag_field('ocean_model', 'tauy', diag%axesCv1, time,  &
        'Meridional surface stress ocean interactions with atmos and ice', &
        'Pa',  conversion=us%R_to_kg_m3*us%L_T_to_m_s**2*us%Z_to_L, &
         standard_name='surface_downward_y_stress', cmor_field_name='tauvo',        &
         cmor_units='N m-2', cmor_long_name='Surface Downward Y Stress',            &
         cmor_standard_name='surface_downward_y_stress')
 
  handles%id_ustar = register_diag_field('ocean_model', 'ustar', diag%axesT1, time, &
      'Surface friction velocity = [(gustiness + tau_magnitude)/rho0]^(1/2)', &
      'm s-1', conversion=us%Z_to_m*us%s_to_T)
 
  if (present(use_berg_fluxes)) then
    if (use_berg_fluxes) then
      handles%id_ustar_berg = register_diag_field('ocean_model', 'ustar_berg', diag%axesT1, time, &
          'Friction velocity below iceberg ', 'm s-1', conversion=us%Z_to_m*us%s_to_T)
 
      handles%id_area_berg = register_diag_field('ocean_model', 'area_berg', diag%axesT1, time, &
          'Area of grid cell covered by iceberg ', 'm2 m-2')
 
      handles%id_mass_berg = register_diag_field('ocean_model', 'mass_berg', diag%axesT1, time, &
          'Mass of icebergs ', 'kg m-2')
 
      handles%id_ustar_ice_cover = register_diag_field('ocean_model', 'ustar_ice_cover', diag%axesT1, time, &
          'Friction velocity below iceberg and ice shelf together', 'm s-1', conversion=us%Z_to_m*us%s_to_T)
 
      handles%id_frac_ice_cover = register_diag_field('ocean_model', 'frac_ice_cover', diag%axesT1, time, &
          'Area of grid cell below iceberg and ice shelf together ', 'm2 m-2')
    endif
  endif
 
  handles%id_psurf = register_diag_field('ocean_model', 'p_surf', diag%axesT1, time,           &
        'Pressure at ice-ocean or atmosphere-ocean interface', 'Pa', cmor_field_name='pso',    &
        cmor_long_name='Sea Water Pressure at Sea Water Surface',                              &
        cmor_standard_name='sea_water_pressure_at_sea_water_surface')
 
  handles%id_TKE_tidal = register_diag_field('ocean_model', 'TKE_tidal', diag%axesT1, time, &
        'Tidal source of BBL mixing', 'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m**3*us%s_to_T**3)
 
  if (.not. use_temperature) then
    handles%id_buoy = register_diag_field('ocean_model', 'buoy', diag%axesT1, time, &
          'Buoyancy forcing', 'm2 s-3', conversion=us%L_to_m**2*us%s_to_T**3)
    return
  endif
 
 
  !===============================================================
  ! surface mass flux maps
 
  handles%id_prcme = register_diag_field('ocean_model', 'PRCmE', diag%axesT1, time,                  &
        'Net surface water flux (precip+melt+lrunoff+ice calving-evap)', 'kg m-2 s-1', &
        standard_name='water_flux_into_sea_water', cmor_field_name='wfo',                            &
        cmor_standard_name='water_flux_into_sea_water',cmor_long_name='Water Flux Into Sea Water')
        ! This diagnostic is rescaled to MKS units when combined.
 
  handles%id_evap = register_diag_field('ocean_model', 'evap', diag%axesT1, time, &
       'Evaporation/condensation at ocean surface (evaporation is negative)', &
       'kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
       standard_name='water_evaporation_flux', cmor_field_name='evs', &
       cmor_standard_name='water_evaporation_flux', &
       cmor_long_name='Water Evaporation Flux Where Ice Free Ocean over Sea')
 
  ! smg: seaice_melt field requires updates to the sea ice model
  handles%id_seaice_melt = register_diag_field('ocean_model', 'seaice_melt',       &
     diag%axesT1, time, 'water flux to ocean from snow/sea ice melting(> 0) or formation(< 0)', &
     'kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
      standard_name='water_flux_into_sea_water_due_to_sea_ice_thermodynamics',     &
      cmor_field_name='fsitherm',                                                  &
      cmor_standard_name='water_flux_into_sea_water_due_to_sea_ice_thermodynamics',&
      cmor_long_name='water flux to ocean from sea ice melt(> 0) or form(< 0)')
 
  handles%id_precip = register_diag_field('ocean_model', 'precip', diag%axesT1, time, &
        'Liquid + frozen precipitation into ocean', 'kg m-2 s-1')
        ! This diagnostic is rescaled to MKS units when combined.
 
  handles%id_fprec = register_diag_field('ocean_model', 'fprec', diag%axesT1, time,     &
        'Frozen precipitation into ocean', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T,   &
        standard_name='snowfall_flux', cmor_field_name='prsn',                          &
        cmor_standard_name='snowfall_flux', cmor_long_name='Snowfall Flux where Ice Free Ocean over Sea')
 
  handles%id_lprec = register_diag_field('ocean_model', 'lprec', diag%axesT1, time,       &
        'Liquid precipitation into ocean', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T,                 &
        standard_name='rainfall_flux',                                                    &
        cmor_field_name='prlq', cmor_standard_name='rainfall_flux',                       &
        cmor_long_name='Rainfall Flux where Ice Free Ocean over Sea')
 
  handles%id_vprec = register_diag_field('ocean_model', 'vprec', diag%axesT1, time, &
        'Virtual liquid precip into ocean due to SSS restoring', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_frunoff = register_diag_field('ocean_model', 'frunoff', diag%axesT1, time,    &
        'Frozen runoff (calving) and iceberg melt into ocean', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        standard_name='water_flux_into_sea_water_from_icebergs',                           &
        cmor_field_name='ficeberg',                                                        &
        cmor_standard_name='water_flux_into_sea_water_from_icebergs',                      &
        cmor_long_name='Water Flux into Seawater from Icebergs')
 
  handles%id_lrunoff = register_diag_field('ocean_model', 'lrunoff', diag%axesT1, time, &
        'Liquid runoff (rivers) into ocean', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        standard_name='water_flux_into_sea_water_from_rivers', cmor_field_name='friver',      &
        cmor_standard_name='water_flux_into_sea_water_from_rivers',                           &
        cmor_long_name='Water Flux into Sea Water From Rivers')
 
  handles%id_net_massout = register_diag_field('ocean_model', 'net_massout', diag%axesT1, time, &
        'Net mass leaving the ocean due to evaporation, seaice formation', 'kg m-2 s-1')
        ! This diagnostic is rescaled to MKS units when combined.
 
  handles%id_net_massin  = register_diag_field('ocean_model', 'net_massin', diag%axesT1, time, &
        'Net mass entering ocean due to precip, runoff, ice melt', 'kg m-2 s-1')
        ! This diagnostic is rescaled to MKS units when combined.
 
  handles%id_massout_flux = register_diag_field('ocean_model', 'massout_flux', diag%axesT1, time, &
        'Net mass flux of freshwater out of the ocean (used in the boundary flux calculation)', &
         'kg m-2', conversion=diag%GV%H_to_kg_m2)
        ! This diagnostic is calculated in MKS units.
 
  handles%id_massin_flux  = register_diag_field('ocean_model', 'massin_flux', diag%axesT1, time, &
        'Net mass flux of freshwater into the ocean (used in boundary flux calculation)', 'kg m-2')
        ! This diagnostic is calculated in MKS units.
 
  !=========================================================================
  ! area integrated surface mass transport, all are rescaled to MKS units before area integration.
 
  handles%id_total_prcme = register_scalar_field('ocean_model', 'total_PRCmE', time, diag,         &
      long_name='Area integrated net surface water flux (precip+melt+liq runoff+ice calving-evap)',&
      units='kg s-1', standard_name='water_flux_into_sea_water_area_integrated',                   &
      cmor_field_name='total_wfo',                                                                 &
      cmor_standard_name='water_flux_into_sea_water_area_integrated',                              &
      cmor_long_name='Water Transport Into Sea Water Area Integrated')
 
  handles%id_total_evap = register_scalar_field('ocean_model', 'total_evap', time, diag,&
      long_name='Area integrated evap/condense at ocean surface',                       &
      units='kg s-1', standard_name='water_evaporation_flux_area_integrated',           &
      cmor_field_name='total_evs',                                                      &
      cmor_standard_name='water_evaporation_flux_area_integrated',                      &
      cmor_long_name='Evaporation Where Ice Free Ocean over Sea Area Integrated')
 
  ! seaice_melt field requires updates to the sea ice model
  handles%id_total_seaice_melt = register_scalar_field('ocean_model', 'total_icemelt', time, diag, &
      long_name='Area integrated sea ice melt (>0) or form (<0)', units='kg s-1',                      &
      standard_name='water_flux_into_sea_water_due_to_sea_ice_thermodynamics_area_integrated',         &
      cmor_field_name='total_fsitherm',                                                                &
      cmor_standard_name='water_flux_into_sea_water_due_to_sea_ice_thermodynamics_area_integrated',    &
      cmor_long_name='Water Melt/Form from Sea Ice Area Integrated')
 
  handles%id_total_precip = register_scalar_field('ocean_model', 'total_precip', time, diag, &
      long_name='Area integrated liquid+frozen precip into ocean', units='kg s-1')
 
  handles%id_total_fprec = register_scalar_field('ocean_model', 'total_fprec', time, diag,&
      long_name='Area integrated frozen precip into ocean', units='kg s-1',               &
      standard_name='snowfall_flux_area_integrated',                                      &
      cmor_field_name='total_prsn',                                                       &
      cmor_standard_name='snowfall_flux_area_integrated',                                 &
      cmor_long_name='Snowfall Flux where Ice Free Ocean over Sea Area Integrated')
 
  handles%id_total_lprec = register_scalar_field('ocean_model', 'total_lprec', time, diag,&
      long_name='Area integrated liquid precip into ocean', units='kg s-1',               &
      standard_name='rainfall_flux_area_integrated',                                      &
      cmor_field_name='total_pr',                                                         &
      cmor_standard_name='rainfall_flux_area_integrated',                                 &
      cmor_long_name='Rainfall Flux where Ice Free Ocean over Sea Area Integrated')
 
  handles%id_total_vprec = register_scalar_field('ocean_model', 'total_vprec', time, diag, &
      long_name='Area integrated virtual liquid precip due to SSS restoring', units='kg s-1')
 
  handles%id_total_frunoff = register_scalar_field('ocean_model', 'total_frunoff', time, diag,    &
      long_name='Area integrated frozen runoff (calving) & iceberg melt into ocean', units='kg s-1',&
      cmor_field_name='total_ficeberg',                                                           &
      cmor_standard_name='water_flux_into_sea_water_from_icebergs_area_integrated',               &
      cmor_long_name='Water Flux into Seawater from Icebergs Area Integrated')
 
  handles%id_total_lrunoff = register_scalar_field('ocean_model', 'total_lrunoff', time, diag,&
      long_name='Area integrated liquid runoff into ocean', units='kg s-1',                   &
      cmor_field_name='total_friver',                                                         &
      cmor_standard_name='water_flux_into_sea_water_from_rivers_area_integrated',             &
      cmor_long_name='Water Flux into Sea Water From Rivers Area Integrated')
 
  handles%id_total_net_massout = register_scalar_field('ocean_model', 'total_net_massout', time, diag, &
      long_name='Area integrated mass leaving ocean due to evap and seaice form', units='kg s-1')
 
  handles%id_total_net_massin = register_scalar_field('ocean_model', 'total_net_massin', time, diag, &
      long_name='Area integrated mass entering ocean due to predip, runoff, ice melt', units='kg s-1')
 
  !=========================================================================
  ! area averaged surface mass transport
 
  handles%id_prcme_ga = register_scalar_field('ocean_model', 'PRCmE_ga', time, diag,             &
      long_name='Area averaged net surface water flux (precip+melt+liq runoff+ice calving-evap)',&
      units='kg m-2 s-1', standard_name='water_flux_into_sea_water_area_averaged',               &
      cmor_field_name='ave_wfo',                                                                 &
      cmor_standard_name='rainfall_flux_area_averaged',                                          &
      cmor_long_name='Water Transport Into Sea Water Area Averaged')
 
  handles%id_evap_ga = register_scalar_field('ocean_model', 'evap_ga', time, diag,&
      long_name='Area averaged evap/condense at ocean surface',                   &
      units='kg m-2 s-1', standard_name='water_evaporation_flux_area_averaged',   &
      cmor_field_name='ave_evs',                                                  &
      cmor_standard_name='water_evaporation_flux_area_averaged',                  &
      cmor_long_name='Evaporation Where Ice Free Ocean over Sea Area Averaged')
 
 handles%id_lprec_ga = register_scalar_field('ocean_model', 'lprec_ga', time, diag,&
      long_name='Area integrated liquid precip into ocean', units='kg m-2 s-1',    &
      standard_name='rainfall_flux_area_averaged',                                 &
      cmor_field_name='ave_pr',                                                    &
      cmor_standard_name='rainfall_flux_area_averaged',                            &
      cmor_long_name='Rainfall Flux where Ice Free Ocean over Sea Area Averaged')
 
 handles%id_fprec_ga = register_scalar_field('ocean_model', 'fprec_ga', time, diag,&
      long_name='Area integrated frozen precip into ocean', units='kg m-2 s-1',    &
      standard_name='snowfall_flux_area_averaged',                                 &
      cmor_field_name='ave_prsn',                                                  &
      cmor_standard_name='snowfall_flux_area_averaged',                            &
      cmor_long_name='Snowfall Flux where Ice Free Ocean over Sea Area Averaged')
 
  handles%id_precip_ga = register_scalar_field('ocean_model', 'precip_ga', time, diag, &
      long_name='Area averaged liquid+frozen precip into ocean', units='kg m-2 s-1')
 
  handles%id_vprec_ga = register_scalar_field('ocean_model', 'vrec_ga', time, diag, &
      long_name='Area averaged virtual liquid precip due to SSS restoring', units='kg m-2 s-1')
 
  !===============================================================
  ! surface heat flux maps
 
  handles%id_heat_content_frunoff = register_diag_field('ocean_model', 'heat_content_frunoff', &
        diag%axesT1, time, 'Heat content (relative to 0C) of solid runoff into ocean',         &
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        standard_name='temperature_flux_due_to_solid_runoff_expressed_as_heat_flux_into_sea_water')
 
  handles%id_heat_content_lrunoff = register_diag_field('ocean_model', 'heat_content_lrunoff', &
        diag%axesT1, time, 'Heat content (relative to 0C) of liquid runoff into ocean',        &
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        standard_name='temperature_flux_due_to_runoff_expressed_as_heat_flux_into_sea_water')
 
  handles%id_hfrunoffds = register_diag_field('ocean_model', 'hfrunoffds',                            &
        diag%axesT1, time, 'Heat content (relative to 0C) of liquid+solid runoff into ocean', &
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        standard_name='temperature_flux_due_to_runoff_expressed_as_heat_flux_into_sea_water')
 
  handles%id_heat_content_lprec = register_diag_field('ocean_model', 'heat_content_lprec',             &
        diag%axesT1,time,'Heat content (relative to 0degC) of liquid precip entering ocean',           &
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_heat_content_fprec = register_diag_field('ocean_model', 'heat_content_fprec',&
        diag%axesT1,time,'Heat content (relative to 0degC) of frozen prec entering ocean',&
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_heat_content_icemelt = register_diag_field('ocean_model', 'heat_content_icemelt',&
        diag%axesT1,time,'Heat content (relative to 0degC) of water flux due to sea ice melting/freezing',&
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_heat_content_vprec = register_diag_field('ocean_model', 'heat_content_vprec',   &
        diag%axesT1,time,'Heat content (relative to 0degC) of virtual precip entering ocean',&
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_heat_content_cond = register_diag_field('ocean_model', 'heat_content_cond',   &
        diag%axesT1,time,'Heat content (relative to 0degC) of water condensing into ocean',&
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_hfrainds = register_diag_field('ocean_model', 'hfrainds',                                 &
        diag%axesT1,time,'Heat content (relative to 0degC) of liquid+frozen precip entering ocean',    &
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        standard_name='temperature_flux_due_to_rainfall_expressed_as_heat_flux_into_sea_water',&
        cmor_long_name='Heat Content (relative to 0degC) of Liquid + Frozen Precipitation')
 
  handles%id_heat_content_surfwater = register_diag_field('ocean_model', 'heat_content_surfwater',&
         diag%axesT1, time,                                                                       &
        'Heat content (relative to 0degC) of net water crossing ocean surface (frozen+liquid)',   &
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_heat_content_massout = register_diag_field('ocean_model', 'heat_content_massout',                      &
         diag%axesT1, time,'Heat content (relative to 0degC) of net mass leaving ocean ocean via evap and ice form',&
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T,                                                      &
        cmor_field_name='hfevapds',                                                                                 &
        cmor_standard_name='temperature_flux_due_to_evaporation_expressed_as_heat_flux_out_of_sea_water',           &
        cmor_long_name='Heat Content (relative to 0degC) of Water Leaving Ocean via Evaporation and Ice Formation')
 
  handles%id_heat_content_massin = register_diag_field('ocean_model', 'heat_content_massin',   &
         diag%axesT1, time,'Heat content (relative to 0degC) of net mass entering ocean ocean',&
        'W m-2', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_net_heat_coupler = register_diag_field('ocean_model', 'net_heat_coupler',          &
        diag%axesT1,time,'Surface ocean heat flux from SW+LW+latent+sensible+seaice_melt_heat (via the coupler)',&
        'W m-2')
 
  handles%id_net_heat_surface = register_diag_field('ocean_model', 'net_heat_surface',diag%axesT1, time,  &
        'Surface ocean heat flux from SW+LW+lat+sens+mass transfer+frazil+restore+seaice_melt_heat or '// &
        'flux adjustments',&
        'W m-2',&
        standard_name='surface_downward_heat_flux_in_sea_water', cmor_field_name='hfds',            &
        cmor_standard_name='surface_downward_heat_flux_in_sea_water',           &
        cmor_long_name='Surface ocean heat flux from SW+LW+latent+sensible+masstransfer+frazil+seaice_melt_heat')
 
  handles%id_sw = register_diag_field('ocean_model', 'SW', diag%axesT1, time,  &
        'Shortwave radiation flux into ocean', 'W m-2',                        &
        standard_name='net_downward_shortwave_flux_at_sea_water_surface',      &
        cmor_field_name='rsntds',                                              &
        cmor_standard_name='net_downward_shortwave_flux_at_sea_water_surface', &
        cmor_long_name='Net Downward Shortwave Radiation at Sea Water Surface')
  handles%id_sw_vis = register_diag_field('ocean_model', 'sw_vis', diag%axesT1, time,     &
        'Shortwave radiation direct and diffuse flux into the ocean in the visible band', &
        'W m-2')
  handles%id_sw_nir = register_diag_field('ocean_model', 'sw_nir', diag%axesT1, time,     &
        'Shortwave radiation direct and diffuse flux into the ocean in the near-infrared band', &
        'W m-2')
 
  handles%id_LwLatSens = register_diag_field('ocean_model', 'LwLatSens', diag%axesT1, time, &
        'Combined longwave, latent, and sensible heating at ocean surface', 'W m-2')
 
  handles%id_lw = register_diag_field('ocean_model', 'LW', diag%axesT1, time, &
        'Longwave radiation flux into ocean', 'W m-2',                        &
        standard_name='surface_net_downward_longwave_flux',                   &
        cmor_field_name='rlntds',                                             &
        cmor_standard_name='surface_net_downward_longwave_flux',              &
        cmor_long_name='Surface Net Downward Longwave Radiation')
 
  handles%id_lat = register_diag_field('ocean_model', 'latent', diag%axesT1, time,                    &
        'Latent heat flux into ocean due to fusion and evaporation (negative means ocean heat loss)', &
        'W m-2', cmor_field_name='hflso',                                                             &
        cmor_standard_name='surface_downward_latent_heat_flux',                                       &
        cmor_long_name='Surface Downward Latent Heat Flux due to Evap + Melt Snow/Ice')
 
  handles%id_lat_evap = register_diag_field('ocean_model', 'latent_evap', diag%axesT1, time, &
        'Latent heat flux into ocean due to evaporation/condensation', 'W m-2')
 
  handles%id_lat_fprec = register_diag_field('ocean_model', 'latent_fprec_diag', diag%axesT1, time,&
        'Latent heat flux into ocean due to melting of frozen precipitation', 'W m-2',             &
        cmor_field_name='hfsnthermds',                                                             &
        cmor_standard_name='heat_flux_into_sea_water_due_to_snow_thermodynamics',                  &
        cmor_long_name='Latent Heat to Melt Frozen Precipitation')
 
  handles%id_lat_frunoff = register_diag_field('ocean_model', 'latent_frunoff', diag%axesT1, time, &
        'Latent heat flux into ocean due to melting of icebergs', 'W m-2',                         &
        cmor_field_name='hfibthermds',                                                             &
        cmor_standard_name='heat_flux_into_sea_water_due_to_iceberg_thermodynamics',               &
        cmor_long_name='Latent Heat to Melt Frozen Runoff/Iceberg')
 
  handles%id_sens = register_diag_field('ocean_model', 'sensible', diag%axesT1, time,&
        'Sensible heat flux into ocean', 'W m-2',                                    &
        standard_name='surface_downward_sensible_heat_flux',                         &
        cmor_field_name='hfsso',                                                     &
        cmor_standard_name='surface_downward_sensible_heat_flux',                    &
        cmor_long_name='Surface Downward Sensible Heat Flux')
 
  handles%id_seaice_melt_heat = register_diag_field('ocean_model', 'seaice_melt_heat', diag%axesT1, time,&
        'Heat flux into ocean due to snow and sea ice melt/freeze', 'W m-2',      &
        standard_name='snow_ice_melt_heat_flux',                         &
  !GMM TODO cmor_field_name='hfsso',                                                     &
        cmor_standard_name='snow_ice_melt_heat_flux',                    &
        cmor_long_name='Heat flux into ocean from snow and sea ice melt')
 
  handles%id_heat_added = register_diag_field('ocean_model', 'heat_added', diag%axesT1, time, &
        'Flux Adjustment or restoring surface heat flux into ocean', 'W m-2')
 
 
  !===============================================================
  ! area integrated surface heat fluxes
 
  handles%id_total_heat_content_frunoff = register_scalar_field('ocean_model',                     &
      'total_heat_content_frunoff', time, diag,                                                    &
      long_name='Area integrated heat content (relative to 0C) of solid runoff',                   &
      units='W', cmor_field_name='total_hfsolidrunoffds',                                          &
      cmor_standard_name=                                                                          &
      'temperature_flux_due_to_solid_runoff_expressed_as_heat_flux_into_sea_water_area_integrated',&
      cmor_long_name=                                                                              &
      'Temperature Flux due to Solid Runoff Expressed as Heat Flux into Sea Water Area Integrated')
 
  handles%id_total_heat_content_lrunoff = register_scalar_field('ocean_model',               &
      'total_heat_content_lrunoff', time, diag,                                              &
      long_name='Area integrated heat content (relative to 0C) of liquid runoff',            &
      units='W', cmor_field_name='total_hfrunoffds',                                         &
      cmor_standard_name=                                                                    &
      'temperature_flux_due_to_runoff_expressed_as_heat_flux_into_sea_water_area_integrated',&
      cmor_long_name=                                                                        &
      'Temperature Flux due to Runoff Expressed as Heat Flux into Sea Water Area Integrated')
 
  handles%id_total_heat_content_lprec = register_scalar_field('ocean_model',                   &
      'total_heat_content_lprec', time, diag,                                                  &
      long_name='Area integrated heat content (relative to 0C) of liquid precip',              &
      units='W', cmor_field_name='total_hfrainds',                                             &
      cmor_standard_name=                                                                      &
      'temperature_flux_due_to_rainfall_expressed_as_heat_flux_into_sea_water_area_integrated',&
      cmor_long_name=                                                                          &
      'Temperature Flux due to Rainfall Expressed as Heat Flux into Sea Water Area Integrated')
 
  handles%id_total_heat_content_fprec = register_scalar_field('ocean_model',     &
      'total_heat_content_fprec', time, diag,                                    &
      long_name='Area integrated heat content (relative to 0C) of frozen precip',&
      units='W')
 
  handles%id_total_heat_content_icemelt = register_scalar_field('ocean_model',     &
      'total_heat_content_icemelt', time, diag,long_name=                          &
      'Area integrated heat content (relative to 0C) of water flux due sea ice melting/freezing', &
      units='W')
 
  handles%id_total_heat_content_vprec = register_scalar_field('ocean_model',      &
      'total_heat_content_vprec', time, diag,                                     &
      long_name='Area integrated heat content (relative to 0C) of virtual precip',&
      units='W')
 
  handles%id_total_heat_content_cond = register_scalar_field('ocean_model',   &
      'total_heat_content_cond', time, diag,                                  &
      long_name='Area integrated heat content (relative to 0C) of condensate',&
      units='W')
 
  handles%id_total_heat_content_surfwater = register_scalar_field('ocean_model',          &
      'total_heat_content_surfwater', time, diag,                                         &
      long_name='Area integrated heat content (relative to 0C) of water crossing surface',&
      units='W')
 
  handles%id_total_heat_content_massout = register_scalar_field('ocean_model',                      &
      'total_heat_content_massout', time, diag,                                                     &
      long_name='Area integrated heat content (relative to 0C) of water leaving ocean',             &
      units='W',                                                                                    &
      cmor_field_name='total_hfevapds',                                                             &
      cmor_standard_name=                                                                           &
      'temperature_flux_due_to_evaporation_expressed_as_heat_flux_out_of_sea_water_area_integrated',&
      cmor_long_name='Heat Flux Out of Sea Water due to Evaporating Water Area Integrated')
 
  handles%id_total_heat_content_massin = register_scalar_field('ocean_model',           &
      'total_heat_content_massin', time, diag,                                          &
      long_name='Area integrated heat content (relative to 0C) of water entering ocean',&
      units='W')
 
  handles%id_total_net_heat_coupler = register_scalar_field('ocean_model',                       &
      'total_net_heat_coupler', time, diag,                                                      &
      long_name='Area integrated surface heat flux from SW+LW+latent+sensible+seaice_melt_heat (via the coupler)',&
      units='W')
 
  handles%id_total_net_heat_surface = register_scalar_field('ocean_model',                      &
      'total_net_heat_surface', time, diag,                                                     &
      long_name='Area integrated surface heat flux from SW+LW+lat+sens+mass+frazil+restore or flux adjustments', &
      units='W',                                                                                &
      cmor_field_name='total_hfds',                                                             &
      cmor_standard_name='surface_downward_heat_flux_in_sea_water_area_integrated',             &
      cmor_long_name=                                                                           &
      'Surface Ocean Heat Flux from SW+LW+latent+sensible+mass transfer+frazil Area Integrated')
 
  handles%id_total_sw = register_scalar_field('ocean_model',                                &
      'total_sw', time, diag,                                                               &
      long_name='Area integrated net downward shortwave at sea water surface',              &
      units='W',                                                                            &
      cmor_field_name='total_rsntds',                                                       &
      cmor_standard_name='net_downward_shortwave_flux_at_sea_water_surface_area_integrated',&
      cmor_long_name=                                                                       &
      'Net Downward Shortwave Radiation at Sea Water Surface Area Integrated')
 
  handles%id_total_LwLatSens = register_scalar_field('ocean_model',&
      'total_LwLatSens', time, diag,                               &
      long_name='Area integrated longwave+latent+sensible heating',&
      units='W')
 
  handles%id_total_lw = register_scalar_field('ocean_model',                  &
      'total_lw', time, diag,                                                 &
      long_name='Area integrated net downward longwave at sea water surface', &
      units='W',                                                              &
      cmor_field_name='total_rlntds',                                         &
      cmor_standard_name='surface_net_downward_longwave_flux_area_integrated',&
      cmor_long_name=                                                         &
      'Surface Net Downward Longwave Radiation Area Integrated')
 
  handles%id_total_lat = register_scalar_field('ocean_model',                &
      'total_lat', time, diag,                                               &
      long_name='Area integrated surface downward latent heat flux',         &
      units='W',                                                             &
      cmor_field_name='total_hflso',                                         &
      cmor_standard_name='surface_downward_latent_heat_flux_area_integrated',&
      cmor_long_name=                                                        &
      'Surface Downward Latent Heat Flux Area Integrated')
 
  handles%id_total_lat_evap = register_scalar_field('ocean_model',      &
      'total_lat_evap', time, diag,                                     &
      long_name='Area integrated latent heat flux due to evap/condense',&
      units='W')
 
  handles%id_total_lat_fprec = register_scalar_field('ocean_model',                            &
      'total_lat_fprec', time, diag,                                                           &
      long_name='Area integrated latent heat flux due to melting frozen precip',               &
      units='W',                                                                               &
      cmor_field_name='total_hfsnthermds',                                                     &
      cmor_standard_name='heat_flux_into_sea_water_due_to_snow_thermodynamics_area_integrated',&
      cmor_long_name=                                                                          &
      'Latent Heat to Melt Frozen Precipitation Area Integrated')
 
  handles%id_total_lat_frunoff = register_scalar_field('ocean_model',                             &
      'total_lat_frunoff', time, diag,                                                            &
      long_name='Area integrated latent heat flux due to melting icebergs',                       &
      units='W',                                                                                  &
      cmor_field_name='total_hfibthermds',                                                        &
      cmor_standard_name='heat_flux_into_sea_water_due_to_iceberg_thermodynamics_area_integrated',&
      cmor_long_name=                                                                             &
      'Heat Flux into Sea Water due to Iceberg Thermodynamics Area Integrated')
 
  handles%id_total_sens = register_scalar_field('ocean_model',                 &
      'total_sens', time, diag,                                                &
      long_name='Area integrated downward sensible heat flux',                 &
      units='W',                                                               &
      cmor_field_name='total_hfsso',                                           &
      cmor_standard_name='surface_downward_sensible_heat_flux_area_integrated',&
      cmor_long_name=                                                          &
      'Surface Downward Sensible Heat Flux Area Integrated')
 
  handles%id_total_heat_added = register_scalar_field('ocean_model',&
      'total_heat_adjustment', time, diag,                               &
      long_name='Area integrated surface heat flux from restoring and/or flux adjustment',   &
      units='W')
 
  handles%id_total_seaice_melt_heat = register_scalar_field('ocean_model',&
      'total_seaice_melt_heat', time, diag,                               &
      long_name='Area integrated surface heat flux from snow and sea ice melt',   &
      units='W')
 
  !===============================================================
  ! area averaged surface heat fluxes
 
  handles%id_net_heat_coupler_ga = register_scalar_field('ocean_model',                       &
      'net_heat_coupler_ga', time, diag,                                                      &
      long_name='Area averaged surface heat flux from SW+LW+latent+sensible+seaice_melt_heat (via the coupler)',&
      units='W m-2')
 
  handles%id_net_heat_surface_ga = register_scalar_field('ocean_model',                       &
      'net_heat_surface_ga', time, diag, long_name=                                                     &
      'Area averaged surface heat flux from SW+LW+lat+sens+mass+frazil+restore+seaice_melt_heat or flux adjustments', &
      units='W m-2',                                                                          &
      cmor_field_name='ave_hfds',                                                             &
      cmor_standard_name='surface_downward_heat_flux_in_sea_water_area_averaged',             &
      cmor_long_name=                                                                         &
      'Surface Ocean Heat Flux from SW+LW+latent+sensible+mass transfer+frazil Area Averaged')
 
  handles%id_sw_ga = register_scalar_field('ocean_model',                                 &
      'sw_ga', time, diag,                                                                &
      long_name='Area averaged net downward shortwave at sea water surface',              &
      units='W m-2',                                                                      &
      cmor_field_name='ave_rsntds',                                                       &
      cmor_standard_name='net_downward_shortwave_flux_at_sea_water_surface_area_averaged',&
      cmor_long_name=                                                                     &
      'Net Downward Shortwave Radiation at Sea Water Surface Area Averaged')
 
  handles%id_LwLatSens_ga = register_scalar_field('ocean_model',&
      'LwLatSens_ga', time, diag,                               &
      long_name='Area averaged longwave+latent+sensible heating',&
      units='W m-2')
 
  handles%id_lw_ga = register_scalar_field('ocean_model',                   &
      'lw_ga', time, diag,                                                  &
      long_name='Area averaged net downward longwave at sea water surface', &
      units='W m-2',                                                        &
      cmor_field_name='ave_rlntds',                                         &
      cmor_standard_name='surface_net_downward_longwave_flux_area_averaged',&
      cmor_long_name=                                                       &
      'Surface Net Downward Longwave Radiation Area Averaged')
 
  handles%id_lat_ga = register_scalar_field('ocean_model',                 &
      'lat_ga', time, diag,                                                &
      long_name='Area averaged surface downward latent heat flux',         &
      units='W m-2',                                                       &
      cmor_field_name='ave_hflso',                                         &
      cmor_standard_name='surface_downward_latent_heat_flux_area_averaged',&
      cmor_long_name=                                                      &
      'Surface Downward Latent Heat Flux Area Averaged')
 
  handles%id_sens_ga = register_scalar_field('ocean_model',                  &
      'sens_ga', time, diag,                                                 &
      long_name='Area averaged downward sensible heat flux',                 &
      units='W m-2',                                                         &
      cmor_field_name='ave_hfsso',                                           &
      cmor_standard_name='surface_downward_sensible_heat_flux_area_averaged',&
      cmor_long_name=                                                        &
      'Surface Downward Sensible Heat Flux Area Averaged')
 
 
  !===============================================================
  ! maps of surface salt fluxes, virtual precip fluxes, and adjustments
 
  handles%id_saltflux = register_diag_field('ocean_model', 'salt_flux', diag%axesT1, time,&
        'Net salt flux into ocean at surface (restoring + sea-ice)',                      &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T, &
        cmor_field_name='sfdsi', cmor_standard_name='downward_sea_ice_basal_salt_flux', &
        cmor_long_name='Downward Sea Ice Basal Salt Flux')
 
  handles%id_saltFluxIn = register_diag_field('ocean_model', 'salt_flux_in', diag%axesT1, time, &
        'Salt flux into ocean at surface from coupler', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_saltFluxAdded = register_diag_field('ocean_model', 'salt_flux_added', &
        diag%axesT1,time,'Salt flux into ocean at surface due to restoring or flux adjustment', &
        units='kg m-2 s-1', conversion=us%R_to_kg_m3*us%Z_to_m*us%s_to_T)
 
  handles%id_saltFluxGlobalAdj = register_scalar_field('ocean_model',              &
        'salt_flux_global_restoring_adjustment', time, diag,                       &
        'Adjustment needed to balance net global salt flux into ocean at surface', &
         units='kg m-2 s-1') !, conversion=US%R_to_kg_m3*US%Z_to_m*US%s_to_T)
 
  handles%id_vPrecGlobalAdj = register_scalar_field('ocean_model',  &
        'vprec_global_adjustment', time, diag,                      &
        'Adjustment needed to adjust net vprec into ocean to zero', &
        'kg m-2 s-1')
 
  handles%id_netFWGlobalAdj = register_scalar_field('ocean_model',       &
        'net_fresh_water_global_adjustment', time, diag,                 &
        'Adjustment needed to adjust net fresh water into ocean to zero',&
        'kg m-2 s-1')
 
  handles%id_saltFluxGlobalScl = register_scalar_field('ocean_model',            &
        'salt_flux_global_restoring_scaling', time, diag,                        &
        'Scaling applied to balance net global salt flux into ocean at surface', &
        'nondim')
 
  handles%id_vPrecGlobalScl = register_scalar_field('ocean_model',&
        'vprec_global_scaling', time, diag,                       &
        'Scaling applied to adjust net vprec into ocean to zero', &
        'nondim')
 
  handles%id_netFWGlobalScl = register_scalar_field('ocean_model',      &
        'net_fresh_water_global_scaling', time, diag,                   &
        'Scaling applied to adjust net fresh water into ocean to zero', &
        'nondim')
 
  !===============================================================
  ! area integrals of surface salt fluxes
 
  handles%id_total_saltflux = register_scalar_field('ocean_model',          &
      'total_salt_flux', time, diag,                                        &
      long_name='Area integrated surface salt flux', units='kg',            &
      cmor_field_name='total_sfdsi',                                        &
      cmor_units='kg s-1',                                                  &
      cmor_standard_name='downward_sea_ice_basal_salt_flux_area_integrated',&
      cmor_long_name='Downward Sea Ice Basal Salt Flux Area Integrated')
 
  handles%id_total_saltFluxIn = register_scalar_field('ocean_model', 'total_salt_Flux_In', &
      time, diag, long_name='Area integrated surface salt flux at surface from coupler', units='kg')
 
  handles%id_total_saltFluxAdded = register_scalar_field('ocean_model', 'total_salt_Flux_Added', &
      time, diag, long_name='Area integrated surface salt flux due to restoring or flux adjustment', units='kg')
 
 

set_derived_forcing_fields()

subroutine, public mom_forcing_type::set_derived_forcing_fields	(	type(mech_forcing), intent(in)	forces,
		type(forcing), intent(inout)	fluxes,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		real, intent(in)	Rho0
	)

This subroutine calculates certain derived forcing fields based on information from a mech_forcing type and stores them in a (thermodynamic) forcing type.

Parameters

[in]	forces	A structure with the driving mechanical forces
[in,out]	fluxes	A structure containing thermodynamic forcing fields
[in]	g	grid type
[in]	us	A dimensional unit scaling type
[in]	rho0	A reference density of seawater [R ~> kg m-3], as used to calculate ustar.

Definition at line 2089 of file MOM_forcing_type.F90.

  type(mech_forcing),      intent(in)    :: forces   !< A structure with the driving mechanical forces
  type(forcing),           intent(inout) :: fluxes   !< A structure containing thermodynamic forcing fields
  type(ocean_grid_type),   intent(in)    :: G        !< grid type
  type(unit_scale_type),   intent(in)    :: US       !< A dimensional unit scaling type
  real,                    intent(in)    :: Rho0     !< A reference density of seawater [R ~> kg m-3],
                                                     !! as used to calculate ustar.
 
  real :: taux2, tauy2 ! Squared wind stress components [R2 L2 Z2 T-4 ~> Pa2].
  real :: Irho0        ! Inverse of the mean density rescaled to [Z L-1 R-1 ~> m3 kg-1]
  integer :: i, j, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
 
  irho0 = us%L_to_Z / rho0
 
  if (associated(forces%taux) .and. associated(forces%tauy) .and. &
      associated(fluxes%ustar_gustless)) then
    do j=js,je ; do i=is,ie
      taux2 = 0.0
      if ((g%mask2dCu(i-1,j) + g%mask2dCu(i,j)) > 0) &
        taux2 = (g%mask2dCu(i-1,j) * forces%taux(i-1,j)**2 + &
                 g%mask2dCu(i,j) * forces%taux(i,j)**2) / &
                (g%mask2dCu(i-1,j) + g%mask2dCu(i,j))
      tauy2 = 0.0
      if ((g%mask2dCv(i,j-1) + g%mask2dCv(i,j)) > 0) &
        tauy2 = (g%mask2dCv(i,j-1) * forces%tauy(i,j-1)**2 + &
                 g%mask2dCv(i,j) * forces%tauy(i,j)**2) / &
                (g%mask2dCv(i,j-1) + g%mask2dCv(i,j))
 
      fluxes%ustar_gustless(i,j) = sqrt(us%L_to_Z * sqrt(taux2 + tauy2) / rho0)
!### For efficiency this could be changed to:
!      fluxes%ustar_gustless(i,j) = sqrt(sqrt(taux2 + tauy2) * Irho0)
    enddo ; enddo
  endif
 

set_net_mass_forcing()

subroutine, public mom_forcing_type::set_net_mass_forcing	(	type(forcing), intent(in)	fluxes,
		type(mech_forcing), intent(inout)	forces,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US
	)

This subroutine determines the net mass source to the ocean from a (thermodynamic) forcing type and stores it in a mech_forcing type.

Parameters

[in]	fluxes	A structure containing thermodynamic forcing fields
[in,out]	forces	A structure with the driving mechanical forces
[in]	us	A dimensional unit scaling type
[in]	g	The ocean grid type

Definition at line 2129 of file MOM_forcing_type.F90.

  type(forcing),           intent(in)    :: fluxes   !< A structure containing thermodynamic forcing fields
  type(mech_forcing),      intent(inout) :: forces   !< A structure with the driving mechanical forces
  type(unit_scale_type),   intent(in)    :: US       !< A dimensional unit scaling type
  type(ocean_grid_type),   intent(in)    :: G        !< The ocean grid type
 
  if (associated(forces%net_mass_src)) &
    call get_net_mass_forcing(fluxes, g, us, forces%net_mass_src)
 

References get_net_mass_forcing().

Here is the call graph for this function: