mom_eos Module Reference

Detailed Description

Provides subroutines for quantities specific to the equation of state.

The MOM_EOS module is a wrapper for various equations of state (e.g. Linear, Wright, UNESCO) and provides a uniform interface to the rest of the model independent of which equation of state is being used.

Data Types
interface	calculate_compress
	Calculates the compressibility of water from T, S, and P. More...
interface	calculate_density
	Calculates density of sea water from T, S and P. More...
interface	calculate_density_derivs
	Calculate the derivatives of density with temperature and salinity from T, S, and P. More...
interface	calculate_density_second_derivs
	Calculates the second derivatives of density with various combinations of temperature, salinity, and pressure from T, S and P. More...
interface	calculate_spec_vol
	Calculates specific volume of sea water from T, S and P. More...
interface	calculate_specific_vol_derivs
	Calculate the derivatives of specific volume with temperature and salinity from T, S, and P. More...
interface	calculate_tfreeze
	Calculates the freezing point of sea water from T, S and P. More...
type	eos_type
	A control structure for the equation of state. More...

Functions/Subroutines
subroutine	calculate_density_scalar (T, S, pressure, rho, EOS, rho_ref, scale)
	Calls the appropriate subroutine to calculate density of sea water for scalar inputs. If rho_ref is present, the anomaly with respect to rho_ref is returned. The pressure and density can be rescaled with the US. If both the US and scale arguments are present the density scaling uses the product of the two scaling factors. More...
subroutine	calculate_stanley_density_scalar (T, S, pressure, Tvar, TScov, Svar, rho, EOS, rho_ref, scale)
	Calls the appropriate subroutine to calculate density of sea water for scalar inputs including the variance of T, S and covariance of T-S. The calculation uses only the second order correction in a series as discussed in Stanley et al., 2020. If rho_ref is present, the anomaly with respect to rho_ref is returned. The density can be rescaled using rho_ref. More...
subroutine	calculate_density_array (T, S, pressure, rho, start, npts, EOS, rho_ref, scale)
	Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs. If rho_ref is present, the anomaly with respect to rho_ref is returned. More...
subroutine	calculate_stanley_density_array (T, S, pressure, Tvar, TScov, Svar, rho, start, npts, EOS, rho_ref, scale)
	Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs including the variance of T, S and covariance of T-S. The calculation uses only the second order correction in a series as discussed in Stanley et al., 2020. If rho_ref is present, the anomaly with respect to rho_ref is returned. More...
subroutine	calculate_density_1d (T, S, pressure, rho, EOS, dom, rho_ref, scale)
	Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs, potentially limiting the domain of indices that are worked on. If rho_ref is present, the anomaly with respect to rho_ref is returned. More...
subroutine	calculate_stanley_density_1d (T, S, pressure, Tvar, TScov, Svar, rho, EOS, dom, rho_ref, scale)
	Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs including the variance of T, S and covariance of T-S, potentially limiting the domain of indices that are worked on. The calculation uses only the second order correction in a series as discussed in Stanley et al., 2020. If rho_ref is present, the anomaly with respect to rho_ref is returned. More...
subroutine	calculate_spec_vol_array (T, S, pressure, specvol, start, npts, EOS, spv_ref, scale)
	Calls the appropriate subroutine to calculate the specific volume of sea water for 1-D array inputs. More...
subroutine	calc_spec_vol_scalar (T, S, pressure, specvol, EOS, spv_ref, scale)
	Calls the appropriate subroutine to calculate specific volume of sea water for scalar inputs. More...
subroutine	calc_spec_vol_1d (T, S, pressure, specvol, EOS, dom, spv_ref, scale)
	Calls the appropriate subroutine to calculate the specific volume of sea water for 1-D array inputs, potentially limiting the domain of indices that are worked on. More...
subroutine	calculate_tfreeze_scalar (S, pressure, T_fr, EOS, pres_scale)
	Calls the appropriate subroutine to calculate the freezing point for scalar inputs. More...
subroutine	calculate_tfreeze_array (S, pressure, T_fr, start, npts, EOS, pres_scale)
	Calls the appropriate subroutine to calculate the freezing point for a 1-D array. More...
subroutine	calculate_density_derivs_array (T, S, pressure, drho_dT, drho_dS, start, npts, EOS, scale)
	Calls the appropriate subroutine to calculate density derivatives for 1-D array inputs. More...
subroutine	calculate_density_derivs_1d (T, S, pressure, drho_dT, drho_dS, EOS, dom, scale)
	Calls the appropriate subroutine to calculate density derivatives for 1-D array inputs. More...
subroutine	calculate_density_derivs_scalar (T, S, pressure, drho_dT, drho_dS, EOS, scale)
	Calls the appropriate subroutines to calculate density derivatives by promoting a scalar to a one-element array. More...
subroutine	calculate_density_second_derivs_array (T, S, pressure, drho_dS_dS, drho_dS_dT, drho_dT_dT, drho_dS_dP, drho_dT_dP, start, npts, EOS, scale)
	Calls the appropriate subroutine to calculate density second derivatives for 1-D array inputs. More...
subroutine	calculate_density_second_derivs_scalar (T, S, pressure, drho_dS_dS, drho_dS_dT, drho_dT_dT, drho_dS_dP, drho_dT_dP, EOS, scale)
	Calls the appropriate subroutine to calculate density second derivatives for scalar nputs. More...
subroutine	calculate_spec_vol_derivs_array (T, S, pressure, dSV_dT, dSV_dS, start, npts, EOS)
	Calls the appropriate subroutine to calculate specific volume derivatives for an array. More...
subroutine	calc_spec_vol_derivs_1d (T, S, pressure, dSV_dT, dSV_dS, EOS, dom, scale)
	Calls the appropriate subroutine to calculate specific volume derivatives for 1-d array inputs, potentially limiting the domain of indices that are worked on. More...
subroutine	calculate_compress_array (T, S, press, rho, drho_dp, start, npts, EOS)
	Calls the appropriate subroutine to calculate the density and compressibility for 1-D array inputs. If US is present, the units of the inputs and outputs are rescaled. More...
subroutine	calculate_compress_scalar (T, S, pressure, rho, drho_dp, EOS)
	Calculate density and compressibility for a scalar. This just promotes the scalar to an array with a singleton dimension and calls calculate_compress_array. If US is present, the units of the inputs and outputs are rescaled. More...
integer function, dimension(2), public	eos_domain (HI, halo)
	This subroutine returns a two point integer array indicating the domain of i-indices to work on in EOS calls based on information from a hor_index type. More...
subroutine, public	analytic_int_specific_vol_dp (T, S, p_t, p_b, alpha_ref, HI, EOS, dza, intp_dza, intx_dza, inty_dza, halo_size, bathyP, dP_tiny, useMassWghtInterp)
	Calls the appropriate subroutine to calculate analytical and nearly-analytical integrals in pressure across layers of geopotential anomalies, which are required for calculating the finite-volume form pressure accelerations in a non-Boussinesq model. There are essentially no free assumptions, apart from the use of Boole's rule to do the horizontal integrals, and from a truncation in the series for log(1-eps/1+eps) that assumes that |eps| < 0.34. More...
subroutine, public	analytic_int_density_dz (T, S, z_t, z_b, rho_ref, rho_0, G_e, HI, EOS, dpa, intz_dpa, intx_dpa, inty_dpa, bathyT, dz_neglect, useMassWghtInterp)
	This subroutine calculates analytical and nearly-analytical integrals of pressure anomalies across layers, which are required for calculating the finite-volume form pressure accelerations in a Boussinesq model. More...
logical function, public	query_compressible (EOS)
	Returns true if the equation of state is compressible (i.e. has pressure dependence) More...
subroutine, public	eos_init (param_file, EOS, US)
	Initializes EOS_type by allocating and reading parameters. More...
subroutine, public	eos_manual_init (EOS, form_of_EOS, form_of_TFreeze, EOS_quadrature, Compressible, Rho_T0_S0, drho_dT, dRho_dS, TFr_S0_P0, dTFr_dS, dTFr_dp)
	Manually initialized an EOS type (intended for unit testing of routines which need a specific EOS) More...
subroutine, public	eos_allocate (EOS)
	Allocates EOS_type. More...
subroutine, public	eos_end (EOS)
	Deallocates EOS_type. More...
subroutine, public	eos_use_linear (Rho_T0_S0, dRho_dT, dRho_dS, EOS, use_quadrature)
	Set equation of state structure (EOS) to linear with given coefficients. More...
subroutine, public	convert_temp_salt_for_teos10 (T, S, HI, kd, mask_z, EOS)
	Convert T&S to Absolute Salinity and Conservative Temperature if using TEOS10. More...
logical function, public	eos_quadrature (EOS)
	Return value of EOS_quadrature. More...
subroutine, public	extract_member_eos (EOS, form_of_EOS, form_of_TFreeze, EOS_quadrature, Compressible, Rho_T0_S0, drho_dT, dRho_dS, TFr_S0_P0, dTFr_dS, dTFr_dp)
	Extractor routine for the EOS type if the members need to be accessed outside this module. More...

Variables
integer, parameter, public	eos_linear = 1
	A named integer specifying an equation of state.
integer, parameter, public	eos_unesco = 2
	A named integer specifying an equation of state.
integer, parameter, public	eos_wright = 3
	A named integer specifying an equation of state.
integer, parameter, public	eos_teos10 = 4
	A named integer specifying an equation of state.
integer, parameter, public	eos_nemo = 5
	A named integer specifying an equation of state.
character *(10), parameter	eos_linear_string = "LINEAR"
	A string for specifying the equation of state.
character *(10), parameter	eos_unesco_string = "UNESCO"
	A string for specifying the equation of state.
character *(10), parameter	eos_wright_string = "WRIGHT"
	A string for specifying the equation of state.
character *(10), parameter	eos_teos10_string = "TEOS10"
	A string for specifying the equation of state.
character *(10), parameter	eos_nemo_string = "NEMO"
	A string for specifying the equation of state.
character *(10), parameter	eos_default = EOS_WRIGHT_STRING
	The default equation of state.
integer, parameter	tfreeze_linear = 1
	A named integer specifying a freezing point expression.
integer, parameter	tfreeze_millero = 2
	A named integer specifying a freezing point expression.
integer, parameter	tfreeze_teos10 = 3
	A named integer specifying a freezing point expression.
character *(10), parameter	tfreeze_linear_string = "LINEAR"
	A string for specifying the freezing point expression.
character *(10), parameter	tfreeze_millero_string = "MILLERO_78"
	A string for specifying freezing point expression.
character *(10), parameter	tfreeze_teos10_string = "TEOS10"
	A string for specifying the freezing point expression.
character *(10), parameter	tfreeze_default = TFREEZE_LINEAR_STRING
	The default freezing point expression.

Function/Subroutine Documentation

analytic_int_density_dz()

subroutine, public mom_eos::analytic_int_density_dz	(	real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	T,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	S,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	z_t,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	z_b,
		real, intent(in)	rho_ref,
		real, intent(in)	rho_0,
		real, intent(in)	G_e,
		type(hor_index_type), intent(in)	HI,
		type(eos_type), pointer	EOS,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(inout)	dpa,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(inout), optional	intz_dpa,
		real, dimension(hi%isdb:hi%iedb,hi%jsd:hi%jed), intent(inout), optional	intx_dpa,
		real, dimension(hi%isd:hi%ied,hi%jsdb:hi%jedb), intent(inout), optional	inty_dpa,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in), optional	bathyT,
		real, intent(in), optional	dz_neglect,
		logical, intent(in), optional	useMassWghtInterp
	)

This subroutine calculates analytical and nearly-analytical integrals of pressure anomalies across layers, which are required for calculating the finite-volume form pressure accelerations in a Boussinesq model.

Parameters

[in]	hi	Ocean horizontal index structure
[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	z_t	Height at the top of the layer in depth units [Z ~> m]
[in]	z_b	Height at the bottom of the layer [Z ~> m]
[in]	rho_ref	A mean density [R ~> kg m-3] or [kg m-3], that is subtracted out to reduce the magnitude of each of the integrals.
[in]	rho_0	A density [R ~> kg m-3] or [kg m-3], that is used to calculate the pressure (as p~=-z*rho_0*G_e) used in the equation of state.
[in]	g_e	The Earth's gravitational acceleration [L2 Z-1 T-2 ~> m s-2] or [m2 Z-1 s-2 ~> m s-2]
	eos	Equation of state structure
[in,out]	dpa	The change in the pressure anomaly
[in,out]	intz_dpa	The integral through the thickness of the
[in,out]	intx_dpa	The integral in x of the difference between
[in,out]	inty_dpa	The integral in y of the difference between
[in]	bathyt	The depth of the bathymetry [Z ~> m]
[in]	dz_neglect	A miniscule thickness change [Z ~> m]
[in]	usemasswghtinterp	If true, uses mass weighting to interpolate T/S for top and bottom integrals.

Definition at line 1257 of file MOM_EOS.F90.

  type(hor_index_type), intent(in)  :: HI !< Ocean horizontal index structure
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: T   !< Potential temperature referenced to the surface [degC]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: S   !< Salinity [ppt]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: z_t !< Height at the top of the layer in depth units [Z ~> m]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: z_b !< Height at the bottom of the layer [Z ~> m]
  real,                 intent(in)  :: rho_ref !< A mean density [R ~> kg m-3] or [kg m-3], that is
                                           !! subtracted out to reduce the magnitude of each of the
                                           !! integrals.
  real,                 intent(in)  :: rho_0 !< A density [R ~> kg m-3] or [kg m-3], that is used
                                           !! to calculate the pressure (as p~=-z*rho_0*G_e)
                                           !! used in the equation of state.
  real,                 intent(in)  :: G_e !< The Earth's gravitational acceleration
                                           !! [L2 Z-1 T-2 ~> m s-2] or [m2 Z-1 s-2 ~> m s-2]
  type(EOS_type),       pointer     :: EOS !< Equation of state structure
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                      intent(inout) :: dpa !< The change in the pressure anomaly
                                           !! across the layer [R L2 T-2 ~> Pa] or [Pa]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
            optional, intent(inout) :: intz_dpa !< The integral through the thickness of the
                                           !! layer of the pressure anomaly relative to the
                                           !! anomaly at the top of the layer [R L2 Z T-2 ~> Pa m]
  real, dimension(HI%IsdB:HI%IedB,HI%jsd:HI%jed), &
            optional, intent(inout) :: intx_dpa !< The integral in x of the difference between
                                          !! the pressure anomaly at the top and bottom of the
                                          !! layer divided by the x grid spacing [R L2 T-2 ~> Pa]
  real, dimension(HI%isd:HI%ied,HI%JsdB:HI%JedB), &
            optional, intent(inout) :: inty_dpa !< The integral in y of the difference between
                                          !! the pressure anomaly at the top and bottom of the
                                          !! layer divided by the y grid spacing [R L2 T-2 ~> Pa]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
              optional, intent(in)  :: bathyT !< The depth of the bathymetry [Z ~> m]
  real,       optional, intent(in)  :: dz_neglect !< A miniscule thickness change [Z ~> m]
  logical,    optional, intent(in)  :: useMassWghtInterp !< If true, uses mass weighting to
                                           !! interpolate T/S for top and bottom integrals.
  ! Local variables
  real :: rho_scale  ! A multiplicative factor by which to scale density from kg m-3 to the
                     ! desired units [R m3 kg-1 ~> 1]
  real :: pres_scale ! A multiplicative factor to convert pressure into Pa [Pa T2 R-1 L-2 ~> 1]
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "int_density_dz called with an unassociated EOS_type EOS.")
 
  ! We should never reach this point with quadrature. EOS_quadrature indicates that numerical
  ! integration be used instead of analytic. This is a safety check.
  if (eos%EOS_quadrature) call mom_error(fatal, "EOS_quadrature is set!")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      rho_scale = eos%kg_m3_to_R
      if (rho_scale /= 1.0) then
        call int_density_dz_linear(t, s, z_t, z_b, rho_ref, rho_0, g_e, hi, &
                         rho_scale*eos%Rho_T0_S0, rho_scale*eos%dRho_dT, rho_scale*eos%dRho_dS, &
                         dpa, intz_dpa, intx_dpa, inty_dpa, bathyt, dz_neglect, usemasswghtinterp)
      else
        call int_density_dz_linear(t, s, z_t, z_b, rho_ref, rho_0, g_e, hi, &
                         eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS, &
                         dpa, intz_dpa, intx_dpa, inty_dpa, bathyt, dz_neglect, usemasswghtinterp)
      endif
    case (eos_wright)
      rho_scale = eos%kg_m3_to_R
      pres_scale = eos%RL2_T2_to_Pa
      if ((rho_scale /= 1.0) .or. (pres_scale /= 1.0)) then
        call int_density_dz_wright(t, s, z_t, z_b, rho_ref, rho_0, g_e, hi, &
                                   dpa, intz_dpa, intx_dpa, inty_dpa, bathyt, &
                                   dz_neglect, usemasswghtinterp, rho_scale, pres_scale)
      else
        call int_density_dz_wright(t, s, z_t, z_b, rho_ref, rho_0, g_e, hi, &
                                   dpa, intz_dpa, intx_dpa, inty_dpa, bathyt, &
                                   dz_neglect, usemasswghtinterp)
      endif
    case default
      call mom_error(fatal, "No analytic integration option is available with this EOS!")
  end select
 

analytic_int_specific_vol_dp()

subroutine, public mom_eos::analytic_int_specific_vol_dp	(	real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	T,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	S,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	p_t,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in)	p_b,
		real, intent(in)	alpha_ref,
		type(hor_index_type), intent(in)	HI,
		type(eos_type), pointer	EOS,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(inout)	dza,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(inout), optional	intp_dza,
		real, dimension(hi%isdb:hi%iedb,hi%jsd:hi%jed), intent(inout), optional	intx_dza,
		real, dimension(hi%isd:hi%ied,hi%jsdb:hi%jedb), intent(inout), optional	inty_dza,
		integer, intent(in), optional	halo_size,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed), intent(in), optional	bathyP,
		real, intent(in), optional	dP_tiny,
		logical, intent(in), optional	useMassWghtInterp
	)

Calls the appropriate subroutine to calculate analytical and nearly-analytical integrals in pressure across layers of geopotential anomalies, which are required for calculating the finite-volume form pressure accelerations in a non-Boussinesq model. There are essentially no free assumptions, apart from the use of Boole's rule to do the horizontal integrals, and from a truncation in the series for log(1-eps/1+eps) that assumes that |eps| < 0.34.

Parameters

[in]	hi	The horizontal index structure
[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	p_t	Pressure at the top of the layer [R L2 T-2 ~> Pa] or [Pa]
[in]	p_b	Pressure at the bottom of the layer [R L2 T-2 ~> Pa] or [Pa]
[in]	alpha_ref	A mean specific volume that is subtracted out to reduce the magnitude of each of the integrals [R-1 ~> m3 kg-1] The calculation is mathematically identical with different values of alpha_ref, but this reduces the effects of roundoff.
	eos	Equation of state structure
[in,out]	dza	The change in the geopotential anomaly across
[in,out]	intp_dza	The integral in pressure through the layer of the
[in,out]	intx_dza	The integral in x of the difference between the
[in,out]	inty_dza	The integral in y of the difference between the
[in]	halo_size	The width of halo points on which to calculate dza.
[in]	bathyp	The pressure at the bathymetry [R L2 T-2 ~> Pa] or [Pa]
[in]	dp_tiny	A miniscule pressure change with the same units as p_t [R L2 T-2 ~> Pa] or [Pa]
[in]	usemasswghtinterp	If true, uses mass weighting to interpolate T/S for top and bottom integrals.

Definition at line 1188 of file MOM_EOS.F90.

  type(hor_index_type), intent(in)  :: HI  !< The horizontal index structure
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: T   !< Potential temperature referenced to the surface [degC]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: S   !< Salinity [ppt]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: p_t !< Pressure at the top of the layer [R L2 T-2 ~> Pa] or [Pa]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(in)  :: p_b !< Pressure at the bottom of the layer [R L2 T-2 ~> Pa] or [Pa]
  real,                 intent(in)  :: alpha_ref !< A mean specific volume that is subtracted out
                            !! to reduce the magnitude of each of the integrals [R-1 ~> m3 kg-1]
                            !! The calculation is mathematically identical with different values of
                            !! alpha_ref, but this reduces the effects of roundoff.
  type(EOS_type),       pointer     :: EOS !< Equation of state structure
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
                        intent(inout) :: dza !< The change in the geopotential anomaly across
                            !! the layer [L2 T-2 ~> m2 s-2] or [m2 s-2]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
              optional, intent(inout) :: intp_dza !< The integral in pressure through the layer of the
                            !! geopotential anomaly relative to the anomaly at the bottom of the
                            !! layer [R L4 T-4 ~> Pa m2 s-2] or [Pa m2 s-2]
  real, dimension(HI%IsdB:HI%IedB,HI%jsd:HI%jed), &
              optional, intent(inout) :: intx_dza !< The integral in x of the difference between the
                            !! geopotential anomaly at the top and bottom of the layer divided by
                            !! the x grid spacing [L2 T-2 ~> m2 s-2] or [m2 s-2]
  real, dimension(HI%isd:HI%ied,HI%JsdB:HI%JedB), &
              optional, intent(inout) :: inty_dza !< The integral in y of the difference between the
                            !! geopotential anomaly at the top and bottom of the layer divided by
                            !! the y grid spacing [L2 T-2 ~> m2 s-2] or [m2 s-2]
  integer,    optional, intent(in)  :: halo_size !< The width of halo points on which to calculate dza.
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed), &
              optional, intent(in)  :: bathyP  !< The pressure at the bathymetry [R L2 T-2 ~> Pa] or [Pa]
  real,       optional, intent(in)  :: dP_tiny !< A miniscule pressure change with
                            !! the same units as p_t [R L2 T-2 ~> Pa] or [Pa]
  logical,    optional, intent(in)  :: useMassWghtInterp !< If true, uses mass weighting
                            !! to interpolate T/S for top and bottom integrals.
  ! Local variables
  real :: pres_scale    ! A unit conversion factor from the rescaled units of pressure to Pa [Pa T2 R-1 L-2 ~> 1]
  real :: SV_scale      ! A multiplicative factor by which to scale specific
                        ! volume from m3 kg-1 to the desired units [kg m-3 R-1 ~> 1]
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "int_specific_vol_dp called with an unassociated EOS_type EOS.")
 
  ! We should never reach this point with quadrature. EOS_quadrature indicates that numerical
  ! integration be used instead of analytic. This is a safety check.
  if (eos%EOS_quadrature) call mom_error(fatal, "EOS_quadrature is set!")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call int_spec_vol_dp_linear(t, s, p_t, p_b, alpha_ref, hi, eos%kg_m3_to_R*eos%Rho_T0_S0, &
                                eos%kg_m3_to_R*eos%dRho_dT, eos%kg_m3_to_R*eos%dRho_dS, dza, &
                                intp_dza, intx_dza, inty_dza, halo_size, &
                                bathyp, dp_tiny, usemasswghtinterp)
    case (eos_wright)
      call int_spec_vol_dp_wright(t, s, p_t, p_b, alpha_ref, hi, dza, intp_dza, intx_dza, &
                                  inty_dza, halo_size, bathyp, dp_tiny, usemasswghtinterp, &
                                  sv_scale=eos%R_to_kg_m3, pres_scale=eos%RL2_T2_to_Pa)
    case default
      call mom_error(fatal, "No analytic integration option is available with this EOS!")
  end select
 

calc_spec_vol_1d()

subroutine mom_eos::calc_spec_vol_1d ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  specvol, type(eos_type), pointer  EOS, integer, dimension(2), intent(in), optional  dom, real, intent(in), optional  spv_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate the specific volume of sea water for 1-D array inputs, potentially limiting the domain of indices that are worked on.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [R L2 T-2 ~> Pa]
[in,out]	specvol	In situ specific volume [R-1 ~> m3 kg-1]
	eos	Equation of state structure
[in]	dom	The domain of indices to work on, taking into account that arrays start at 1.
[in]	spv_ref	A reference specific volume [R-1 ~> m3 kg-1]
[in]	scale	A multiplicative factor by which to scale output specific volume in combination with scaling given by US [various]

Definition at line 571 of file MOM_EOS.F90.

  real, dimension(:),    intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:),    intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:),    intent(in)    :: pressure !< Pressure [R L2 T-2 ~> Pa]
  real, dimension(:),    intent(inout) :: specvol  !< In situ specific volume [R-1 ~> m3 kg-1]
  type(EOS_type),        pointer       :: EOS      !< Equation of state structure
  integer, dimension(2), optional, intent(in) :: dom   !< The domain of indices to work on, taking
                                                       !! into account that arrays start at 1.
  real,                  optional, intent(in) :: spv_ref !< A reference specific volume [R-1 ~> m3 kg-1]
  real,                  optional, intent(in) :: scale !< A multiplicative factor by which to scale
                                                       !! output specific volume in combination with
                                                       !! scaling given by US [various]
  ! Local variables
  real, dimension(size(specvol)) :: pres  ! Pressure converted to [Pa]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  real :: spv_unscale ! A factor to convert specific volume from R-1 to m3 kg-1 [m3 kg-1 R ~> 1]
  real :: spv_scale ! A factor to convert specific volume from m3 kg-1 to the desired units [kg m-3 R-1 ~> 1]
  real :: spv_reference ! spv_ref converted to [m3 kg-1]
  integer :: i, is, ie, npts
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calc_spec_vol_1d called with an unassociated EOS_type EOS.")
 
  if (present(dom)) then
    is = dom(1) ; ie = dom(2) ; npts = 1 + ie - is
  else
    is = 1 ; ie = size(specvol) ; npts = 1 + ie - is
  endif
 
  p_scale = eos%RL2_T2_to_Pa
  spv_unscale = eos%kg_m3_to_R
 
  if ((p_scale == 1.0) .and. (spv_unscale == 1.0)) then
    call calculate_spec_vol_array(t, s, pressure, specvol, is, npts, eos, spv_ref)
  elseif (present(spv_ref)) then ! This is the same as above, but with some extra work to rescale variables.
    do i=is,ie ; pres(i) = p_scale * pressure(i) ; enddo
    spv_reference = spv_unscale*spv_ref
    call calculate_spec_vol_array(t, s, pres, specvol, is, npts, eos, spv_reference)
  else  ! There is rescaling of variables, but spv_ref is not present. Passing a 0 value of spv_ref
        ! changes answers at roundoff for some equations of state, like Wright and UNESCO.
    do i=is,ie ; pres(i) = p_scale * pressure(i) ; enddo
    call calculate_spec_vol_array(t, s, pres, specvol, is, npts, eos)
  endif
 
  spv_scale = eos%R_to_kg_m3
  if (present(scale)) spv_scale = spv_scale * scale
  if (spv_scale /= 1.0) then ; do i=is,ie
    specvol(i) = spv_scale * specvol(i)
  enddo ; endif
 

calc_spec_vol_derivs_1d()

subroutine mom_eos::calc_spec_vol_derivs_1d ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  dSV_dT, real, dimension(:), intent(inout)  dSV_dS, type(eos_type), pointer  EOS, integer, dimension(2), intent(in), optional  dom, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate specific volume derivatives for 1-d array inputs, potentially limiting the domain of indices that are worked on.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [R L2 T-2 ~> Pa]
[in,out]	dsv_dt	The partial derivative of specific volume with potential temperature [R-1 degC-1 ~> m3 kg-1 degC-1]
[in,out]	dsv_ds	The partial derivative of specific volume with salinity [R-1 ppt-1 ~> m3 kg-1 ppt-1]
	eos	Equation of state structure
[in]	dom	The domain of indices to work on, taking into account that arrays start at 1.
[in]	scale	A multiplicative factor by which to scale specific volume in combination with scaling given by US [various]

Definition at line 1040 of file MOM_EOS.F90.

  real, dimension(:), intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:), intent(in)    :: pressure !< Pressure [R L2 T-2 ~> Pa]
  real, dimension(:), intent(inout) :: dSV_dT   !< The partial derivative of specific volume with potential
                                                !! temperature [R-1 degC-1 ~> m3 kg-1 degC-1]
  real, dimension(:), intent(inout) :: dSV_dS   !< The partial derivative of specific volume with salinity
                                                !! [R-1 ppt-1 ~> m3 kg-1 ppt-1]
  type(EOS_type),     pointer       :: EOS      !< Equation of state structure
  integer, dimension(2), optional, intent(in) :: dom   !< The domain of indices to work on, taking
                                                       !! into account that arrays start at 1.
  real,                  optional, intent(in) :: scale !< A multiplicative factor by which to scale specific
                                                !! volume in combination with scaling given by US [various]
 
  ! Local variables
  real, dimension(size(dSV_dT)) :: press   ! Pressure converted to [Pa]
  real :: spv_scale ! A factor to convert specific volume from m3 kg-1 to the desired units [kg R-1 m-3 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  integer :: i, is, ie, npts
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_spec_vol_derivs_1d called with an unassociated EOS_type EOS.")
 
  if (present(dom)) then
    is = dom(1) ; ie = dom(2) ; npts = 1 + ie - is
  else
    is = 1 ; ie = size(dsv_dt) ; npts = 1 + ie - is
  endif
  p_scale = eos%RL2_T2_to_Pa
 
  if (p_scale == 1.0) then
    call calculate_spec_vol_derivs_array(t, s, pressure, dsv_dt, dsv_ds, is, npts, eos)
  else
    do i=is,ie ; press(i) = p_scale * pressure(i) ; enddo
    call calculate_spec_vol_derivs_array(t, s, press, dsv_dt, dsv_ds, is, npts, eos)
  endif
 
  spv_scale = eos%R_to_kg_m3
  if (present(scale)) spv_scale = spv_scale * scale
  if (spv_scale /= 1.0) then ; do i=is,ie
    dsv_dt(i) = spv_scale * dsv_dt(i)
    dsv_ds(i) = spv_scale * dsv_ds(i)
  enddo ; endif
 

calc_spec_vol_scalar()

subroutine mom_eos::calc_spec_vol_scalar ( real, intent(in)  T, real, intent(in)  S, real, intent(in)  pressure, real, intent(out)  specvol, type(eos_type), pointer  EOS, real, intent(in), optional  spv_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate specific volume of sea water for scalar inputs.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[out]	specvol	In situ? specific volume [m3 kg-1] or [R-1 ~> m3 kg-1]
	eos	Equation of state structure
[in]	spv_ref	A reference specific volume [m3 kg-1] or [R-1 m3 kg-1]
[in]	scale	A multiplicative factor by which to scale specific volume in combination with scaling given by US [various]

Definition at line 533 of file MOM_EOS.F90.

  real,           intent(in)  :: T        !< Potential temperature referenced to the surface [degC]
  real,           intent(in)  :: S        !< Salinity [ppt]
  real,           intent(in)  :: pressure !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real,           intent(out) :: specvol  !< In situ? specific volume [m3 kg-1] or [R-1 ~> m3 kg-1]
  type(EOS_type), pointer     :: EOS      !< Equation of state structure
  real, optional, intent(in)  :: spv_ref  !< A reference specific volume [m3 kg-1] or [R-1 m3 kg-1]
  real, optional, intent(in)  :: scale    !< A multiplicative factor by which to scale specific
                                          !! volume in combination with scaling given by US [various]
 
  real, dimension(1) :: Ta, Sa, pres, spv  ! Rescaled single element array versions of the arguments.
  real :: spv_reference ! spv_ref converted to [m3 kg-1]
  real :: spv_scale ! A factor to convert specific volume from m3 kg-1 to the desired units [kg R-1 m-3 ~> 1]
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calc_spec_vol_scalar called with an unassociated EOS_type EOS.")
 
  pres(1) = eos%RL2_T2_to_Pa*pressure
  ta(1) = t ; sa(1) = s
 
  if (present(spv_ref)) then
    spv_reference = eos%kg_m3_to_R*spv_ref
    call calculate_spec_vol_array(ta, sa, pres, spv, 1, 1, eos, spv_reference)
  else
    call calculate_spec_vol_array(ta, sa, pres, spv, 1, 1, eos)
  endif
  specvol = spv(1)
 
  spv_scale = eos%R_to_kg_m3
  if (present(scale)) spv_scale = spv_scale * scale
  if (spv_scale /= 1.0) then
    specvol = spv_scale * specvol
  endif
 

calculate_compress_array()

subroutine mom_eos::calculate_compress_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  press, real, dimension(:), intent(inout)  rho, real, dimension(:), intent(inout)  drho_dp, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS  )

private

Calls the appropriate subroutine to calculate the density and compressibility for 1-D array inputs. If US is present, the units of the inputs and outputs are rescaled.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [PSU]
[in]	press	Pressure [Pa] or [R L2 T-2 ~> Pa]
[in,out]	rho	In situ density [kg m-3] or [R ~> kg m-3]
[in,out]	drho_dp	The partial derivative of density with pressure (also the inverse of the square of sound speed) [s2 m-2] or [T2 L-2]
[in]	start	Starting index within the array
[in]	npts	The number of values to calculate
	eos	Equation of state structure

Definition at line 1089 of file MOM_EOS.F90.

  real, dimension(:), intent(in)  :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)  :: S        !< Salinity [PSU]
  real, dimension(:), intent(in)  :: press    !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real, dimension(:), intent(inout) :: rho      !< In situ density [kg m-3] or [R ~> kg m-3]
  real, dimension(:), intent(inout) :: drho_dp  !< The partial derivative of density with pressure
                                                !! (also the inverse of the square of sound speed)
                                                !! [s2 m-2] or [T2 L-2]
  integer,            intent(in)  :: start    !< Starting index within the array
  integer,            intent(in)  :: npts     !< The number of values to calculate
  type(EOS_type),     pointer     :: EOS      !< Equation of state structure
 
  ! Local variables
  real, dimension(size(press)) :: pressure  ! Pressure converted to [Pa]
  integer :: i, is, ie
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_compress called with an unassociated EOS_type EOS.")
 
  is = start ; ie = is + npts - 1
  do i=is,ie ; pressure(i) = eos%RL2_T2_to_Pa * press(i) ; enddo
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_compress_linear(t, s, pressure, rho, drho_dp, start, npts, &
                                     eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS)
    case (eos_unesco)
      call calculate_compress_unesco(t, s, pressure, rho, drho_dp, start, npts)
    case (eos_wright)
      call calculate_compress_wright(t, s, pressure, rho, drho_dp, start, npts)
    case (eos_teos10)
      call calculate_compress_teos10(t, s, pressure, rho, drho_dp, start, npts)
    case (eos_nemo)
      call calculate_compress_nemo(t, s, pressure, rho, drho_dp, start, npts)
    case default
      call mom_error(fatal, "calculate_compress: EOS%form_of_EOS is not valid.")
  end select
 
  if (eos%kg_m3_to_R /= 1.0) then ; do i=is,ie
    rho(i) = eos%kg_m3_to_R * rho(i)
  enddo ; endif
  if (eos%L_T_to_m_s /= 1.0) then ; do i=is,ie
    drho_dp(i) = eos%L_T_to_m_s**2 * drho_dp(i)
  enddo ; endif
 

calculate_compress_scalar()

subroutine mom_eos::calculate_compress_scalar ( real, intent(in)  T, real, intent(in)  S, real, intent(in)  pressure, real, intent(out)  rho, real, intent(out)  drho_dp, type(eos_type), pointer  EOS  )

private

Calculate density and compressibility for a scalar. This just promotes the scalar to an array with a singleton dimension and calls calculate_compress_array. If US is present, the units of the inputs and outputs are rescaled.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[out]	rho	In situ density [kg m-3] or [R ~> kg m-3]
[out]	drho_dp	The partial derivative of density with pressure (also the inverse of the square of sound speed) [s2 m-2] or [T2 L-2]
	eos	Equation of state structure

Definition at line 1139 of file MOM_EOS.F90.

  real, intent(in)        :: T        !< Potential temperature referenced to the surface [degC]
  real, intent(in)        :: S        !< Salinity [ppt]
  real, intent(in)        :: pressure !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real, intent(out)       :: rho      !< In situ density [kg m-3] or [R ~> kg m-3]
  real, intent(out)       :: drho_dp  !< The partial derivative of density with pressure (also the
                                      !! inverse of the square of sound speed) [s2 m-2] or [T2 L-2]
  type(EOS_type), pointer :: EOS      !< Equation of state structure
 
  ! Local variables
  real, dimension(1) :: Ta, Sa, pa, rhoa, drho_dpa
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_compress called with an unassociated EOS_type EOS.")
  ta(1) = t ; sa(1) = s; pa(1) = pressure
 
  call calculate_compress_array(ta, sa, pa, rhoa, drho_dpa, 1, 1, eos)
  rho = rhoa(1) ; drho_dp = drho_dpa(1)
 

calculate_density_1d()

subroutine mom_eos::calculate_density_1d ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  rho, type(eos_type), pointer  EOS, integer, dimension(2), intent(in), optional  dom, real, intent(in), optional  rho_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs, potentially limiting the domain of indices that are worked on. If rho_ref is present, the anomaly with respect to rho_ref is returned.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [R L2 T-2 ~> Pa]
[in,out]	rho	Density (in-situ if pressure is local) [R ~> kg m-3]
	eos	Equation of state structure
[in]	dom	The domain of indices to work on, taking into account that arrays start at 1.
[in]	rho_ref	A reference density [kg m-3]
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 360 of file MOM_EOS.F90.

  real, dimension(:),    intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:),    intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:),    intent(in)    :: pressure !< Pressure [R L2 T-2 ~> Pa]
  real, dimension(:),    intent(inout) :: rho      !< Density (in-situ if pressure is local) [R ~> kg m-3]
  type(EOS_type),        pointer       :: EOS      !< Equation of state structure
  integer, dimension(2), optional, intent(in) :: dom   !< The domain of indices to work on, taking
                                                       !! into account that arrays start at 1.
  real,                  optional, intent(in) :: rho_ref !< A reference density [kg m-3]
  real,                  optional, intent(in) :: scale !< A multiplicative factor by which to scale density
                                                   !! in combination with scaling given by US [various]
  ! Local variables
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: rho_unscale ! A factor to convert density from R to kg m-3 [kg m-3 R-1 ~> 1]
  real :: rho_reference ! rho_ref converted to [kg m-3]
  real, dimension(size(rho)) :: pres  ! Pressure converted to [Pa]
  integer :: i, is, ie, npts
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_1d called with an unassociated EOS_type EOS.")
 
  if (present(dom)) then
    is = dom(1) ; ie = dom(2) ; npts = 1 + ie - is
  else
    is = 1 ; ie = size(rho) ; npts = 1 + ie - is
  endif
 
  p_scale = eos%RL2_T2_to_Pa
  rho_unscale = eos%R_to_kg_m3
 
  if ((p_scale == 1.0) .and. (rho_unscale == 1.0)) then
    call calculate_density_array(t, s, pressure, rho, is, npts, eos, rho_ref=rho_ref)
  elseif (present(rho_ref)) then ! This is the same as above, but with some extra work to rescale variables.
    do i=is,ie ; pres(i) = p_scale * pressure(i) ; enddo
    rho_reference = rho_unscale*rho_ref
    call calculate_density_array(t, s, pres, rho, is, npts, eos, rho_ref=rho_reference)
  else  ! There is rescaling of variables, but rho_ref is not present. Passing a 0 value of rho_ref
        ! changes answers at roundoff for some equations of state, like Wright and UNESCO.
    do i=is,ie ; pres(i) = p_scale * pressure(i) ; enddo
    call calculate_density_array(t, s, pres, rho, is, npts, eos)
  endif
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  if (rho_scale /= 1.0) then ; do i=is,ie
    rho(i) = rho_scale * rho(i)
  enddo ; endif
 

calculate_density_array()

subroutine mom_eos::calculate_density_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  rho, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS, real, intent(in), optional  rho_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs. If rho_ref is present, the anomaly with respect to rho_ref is returned.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[in,out]	rho	Density (in-situ if pressure is local) [kg m-3] or [R ~> kg m-3]
[in]	start	Start index for computation
[in]	npts	Number of point to compute
	eos	Equation of state structure
[in]	rho_ref	A reference density [kg m-3]
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 263 of file MOM_EOS.F90.

  real, dimension(:), intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:), intent(in)    :: pressure !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real, dimension(:), intent(inout) :: rho      !< Density (in-situ if pressure is local) [kg m-3] or [R ~> kg m-3]
  integer,            intent(in)    :: start    !< Start index for computation
  integer,            intent(in)    :: npts     !< Number of point to compute
  type(EOS_type),     pointer       :: EOS      !< Equation of state structure
  real,                  optional, intent(in) :: rho_ref  !< A reference density [kg m-3]
  real,                  optional, intent(in) :: scale    !< A multiplicative factor by which to scale density
                                                !! in combination with scaling given by US [various]
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_array called with an unassociated EOS_type EOS.")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_linear(t, s, pressure, rho, start, npts, &
                                    eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS, rho_ref)
    case (eos_unesco)
      call calculate_density_unesco(t, s, pressure, rho, start, npts, rho_ref)
    case (eos_wright)
      call calculate_density_wright(t, s, pressure, rho, start, npts, rho_ref)
    case (eos_teos10)
      call calculate_density_teos10(t, s, pressure, rho, start, npts, rho_ref)
    case (eos_nemo)
    call calculate_density_nemo(t, s, pressure, rho, start, npts, rho_ref)
    case default
      call mom_error(fatal, "calculate_density_array: EOS%form_of_EOS is not valid.")
  end select
 
  if (present(scale)) then ; if (scale /= 1.0) then ; do j=start,start+npts-1
    rho(j) = scale * rho(j)
  enddo ; endif ; endif
 

calculate_density_derivs_1d()

subroutine mom_eos::calculate_density_derivs_1d ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  drho_dT, real, dimension(:), intent(inout)  drho_dS, type(eos_type), pointer  EOS, integer, dimension(2), intent(in), optional  dom, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate density derivatives for 1-D array inputs.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [R L2 T-2 ~> Pa]
[in,out]	drho_dt	The partial derivative of density with potential temperature [R degC-1 ~> kg m-3 degC-1]
[in,out]	drho_ds	The partial derivative of density with salinity [R degC-1 ~> kg m-3 ppt-1]
	eos	Equation of state structure
[in]	dom	The domain of indices to work on, taking into account that arrays start at 1.
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 751 of file MOM_EOS.F90.

  real, dimension(:),    intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:),    intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:),    intent(in)    :: pressure !< Pressure [R L2 T-2 ~> Pa]
  real, dimension(:),    intent(inout) :: drho_dT  !< The partial derivative of density with potential
                                                   !! temperature [R degC-1 ~> kg m-3 degC-1]
  real, dimension(:),    intent(inout) :: drho_dS  !< The partial derivative of density with salinity
                                                   !! [R degC-1 ~> kg m-3 ppt-1]
  type(EOS_type),        pointer       :: EOS      !< Equation of state structure
  integer, dimension(2), optional, intent(in) :: dom   !< The domain of indices to work on, taking
                                                       !! into account that arrays start at 1.
  real,                  optional, intent(in) :: scale !< A multiplicative factor by which to scale density
                                                       !! in combination with scaling given by US [various]
  ! Local variables
  real, dimension(size(drho_dT)) :: pres  ! Pressure converted to [Pa]
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  integer :: i, is, ie, npts
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_derivs called with an unassociated EOS_type EOS.")
 
  if (present(dom)) then
    is = dom(1) ; ie = dom(2) ; npts = 1 + ie - is
  else
    is = 1 ; ie = size(drho_dt) ; npts = 1 + ie - is
  endif
 
  p_scale = eos%RL2_T2_to_Pa
 
  if (p_scale == 1.0) then
    call calculate_density_derivs_array(t, s, pressure, drho_dt, drho_ds, is, npts, eos)
  else
    do i=is,ie ; pres(i) = p_scale * pressure(i) ; enddo
    call calculate_density_derivs_array(t, s, pres, drho_dt, drho_ds, is, npts, eos)
  endif
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  if (rho_scale /= 1.0) then ; do i=is,ie
    drho_dt(i) = rho_scale * drho_dt(i)
    drho_ds(i) = rho_scale * drho_ds(i)
  enddo ; endif
 

calculate_density_derivs_array()

subroutine mom_eos::calculate_density_derivs_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  drho_dT, real, dimension(:), intent(inout)  drho_dS, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate density derivatives for 1-D array inputs.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[in,out]	drho_dt	The partial derivative of density with potential temperature [kg m-3 degC-1] or [R degC-1 ~> kg m-3 degC-1]
[in,out]	drho_ds	The partial derivative of density with salinity, in [kg m-3 ppt-1] or [R degC-1 ~> kg m-3 ppt-1]
[in]	start	Starting index within the array
[in]	npts	The number of values to calculate
	eos	Equation of state structure
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 706 of file MOM_EOS.F90.

  real, dimension(:), intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:), intent(in)    :: pressure !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real, dimension(:), intent(inout) :: drho_dT  !< The partial derivative of density with potential
                                                !! temperature [kg m-3 degC-1] or [R degC-1 ~> kg m-3 degC-1]
  real, dimension(:), intent(inout) :: drho_dS  !< The partial derivative of density with salinity,
                                                !! in [kg m-3 ppt-1] or [R degC-1 ~> kg m-3 ppt-1]
  integer,            intent(in)    :: start    !< Starting index within the array
  integer,            intent(in)    :: npts     !< The number of values to calculate
  type(EOS_type),     pointer       :: EOS      !< Equation of state structure
  real,     optional, intent(in)    :: scale !< A multiplicative factor by which to scale density
                                                !! in combination with scaling given by US [various]
 
  ! Local variables
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_derivs called with an unassociated EOS_type EOS.")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_derivs_linear(t, s, pressure, drho_dt, drho_ds, eos%Rho_T0_S0, &
                                           eos%dRho_dT, eos%dRho_dS, start, npts)
    case (eos_unesco)
      call calculate_density_derivs_unesco(t, s, pressure, drho_dt, drho_ds, start, npts)
    case (eos_wright)
      call calculate_density_derivs_wright(t, s, pressure, drho_dt, drho_ds, start, npts)
    case (eos_teos10)
      call calculate_density_derivs_teos10(t, s, pressure, drho_dt, drho_ds, start, npts)
    case (eos_nemo)
      call calculate_density_derivs_nemo(t, s, pressure, drho_dt, drho_ds, start, npts)
    case default
      call mom_error(fatal, "calculate_density_derivs_array: EOS%form_of_EOS is not valid.")
  end select
 
  if (present(scale)) then ; if (scale /= 1.0) then ; do j=start,start+npts-1
    drho_dt(j) = scale * drho_dt(j)
    drho_ds(j) = scale * drho_ds(j)
  enddo ; endif ; endif
 

calculate_density_derivs_scalar()

subroutine mom_eos::calculate_density_derivs_scalar ( real, intent(in)  T, real, intent(in)  S, real, intent(in)  pressure, real, intent(out)  drho_dT, real, intent(out)  drho_dS, type(eos_type), pointer  EOS, real, intent(in), optional  scale  )

private

Calls the appropriate subroutines to calculate density derivatives by promoting a scalar to a one-element array.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[out]	drho_dt	The partial derivative of density with potential temperature [kg m-3 degC-1] or [R degC-1 ~> kg m-3 degC-1]
[out]	drho_ds	The partial derivative of density with salinity, in [kg m-3 ppt-1] or [R ppt-1 ~> kg m-3 ppt-1]
	eos	Equation of state structure
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 800 of file MOM_EOS.F90.

  real,           intent(in)  :: T !< Potential temperature referenced to the surface [degC]
  real,           intent(in)  :: S !< Salinity [ppt]
  real,           intent(in)  :: pressure !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real,           intent(out) :: drho_dT !< The partial derivative of density with potential
                                         !! temperature [kg m-3 degC-1] or [R degC-1 ~> kg m-3 degC-1]
  real,           intent(out) :: drho_dS !< The partial derivative of density with salinity,
                                         !! in [kg m-3 ppt-1] or [R ppt-1 ~> kg m-3 ppt-1]
  type(EOS_type), pointer     :: EOS     !< Equation of state structure
  real, optional, intent(in)  :: scale   !< A multiplicative factor by which to scale density
                                         !! in combination with scaling given by US [various]
  ! Local variables
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_derivs called with an unassociated EOS_type EOS.")
 
  p_scale = eos%RL2_T2_to_Pa
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_derivs_linear(t, s, p_scale*pressure, drho_dt, drho_ds, &
                                           eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS)
    case (eos_wright)
      call calculate_density_derivs_wright(t, s, p_scale*pressure, drho_dt, drho_ds)
    case (eos_teos10)
      call calculate_density_derivs_teos10(t, s, p_scale*pressure, drho_dt, drho_ds)
    case default
      call mom_error(fatal, "calculate_density_derivs_scalar: EOS%form_of_EOS is not valid.")
  end select
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  if (rho_scale /= 1.0) then
    drho_dt = rho_scale * drho_dt
    drho_ds = rho_scale * drho_ds
  endif
 

calculate_density_scalar()

subroutine mom_eos::calculate_density_scalar ( real, intent(in)  T, real, intent(in)  S, real, intent(in)  pressure, real, intent(out)  rho, type(eos_type), pointer  EOS, real, intent(in), optional  rho_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate density of sea water for scalar inputs. If rho_ref is present, the anomaly with respect to rho_ref is returned. The pressure and density can be rescaled with the US. If both the US and scale arguments are present the density scaling uses the product of the two scaling factors.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[out]	rho	Density (in-situ if pressure is local) [kg m-3] or [R ~> kg m-3]
	eos	Equation of state structure
[in]	rho_ref	A reference density [kg m-3]
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 166 of file MOM_EOS.F90.

  real,           intent(in)  :: T        !< Potential temperature referenced to the surface [degC]
  real,           intent(in)  :: S        !< Salinity [ppt]
  real,           intent(in)  :: pressure !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real,           intent(out) :: rho      !< Density (in-situ if pressure is local) [kg m-3] or [R ~> kg m-3]
  type(EOS_type), pointer     :: EOS      !< Equation of state structure
  real, optional, intent(in)  :: rho_ref  !< A reference density [kg m-3]
  real, optional, intent(in)  :: scale    !< A multiplicative factor by which to scale density in
                                          !! combination with scaling given by US [various]
 
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_scalar called with an unassociated EOS_type EOS.")
 
  p_scale = eos%RL2_T2_to_Pa
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_linear(t, s, p_scale*pressure, rho, &
                                    eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS, rho_ref)
    case (eos_unesco)
      call calculate_density_unesco(t, s, p_scale*pressure, rho, rho_ref)
    case (eos_wright)
      call calculate_density_wright(t, s, p_scale*pressure, rho, rho_ref)
    case (eos_teos10)
      call calculate_density_teos10(t, s, p_scale*pressure, rho, rho_ref)
    case (eos_nemo)
      call calculate_density_nemo(t, s, p_scale*pressure, rho, rho_ref)
    case default
      call mom_error(fatal, "calculate_density_scalar: EOS is not valid.")
  end select
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  rho = rho_scale * rho
 

calculate_density_second_derivs_array()

subroutine mom_eos::calculate_density_second_derivs_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  drho_dS_dS, real, dimension(:), intent(inout)  drho_dS_dT, real, dimension(:), intent(inout)  drho_dT_dT, real, dimension(:), intent(inout)  drho_dS_dP, real, dimension(:), intent(inout)  drho_dT_dP, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate density second derivatives for 1-D array inputs.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[in,out]	drho_ds_ds	Partial derivative of beta with respect to S [kg m-3 ppt-2] or [R ppt-2 ~> kg m-3 ppt-2]
[in,out]	drho_ds_dt	Partial derivative of beta with respect to T [kg m-3 ppt-1 degC-1] or [R ppt-1 degC-1 ~> kg m-3 ppt-1 degC-1]
[in,out]	drho_dt_dt	Partial derivative of alpha with respect to T [kg m-3 degC-2] or [R degC-2 ~> kg m-3 degC-2]
[in,out]	drho_ds_dp	Partial derivative of beta with respect to pressure [kg m-3 ppt-1 Pa-1] or [R ppt-1 Pa-1 ~> kg m-3 ppt-1 Pa-1]
[in,out]	drho_dt_dp	Partial derivative of alpha with respect to pressure [kg m-3 degC-1 Pa-1] or [R degC-1 Pa-1 ~> kg m-3 degC-1 Pa-1]
[in]	start	Starting index within the array
[in]	npts	The number of values to calculate
	eos	Equation of state structure
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 844 of file MOM_EOS.F90.

  real, dimension(:), intent(in)  :: T !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)  :: S !< Salinity [ppt]
  real, dimension(:), intent(in)  :: pressure   !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real, dimension(:), intent(inout) :: drho_dS_dS !< Partial derivative of beta with respect to S
                                                  !!  [kg m-3 ppt-2] or [R ppt-2 ~> kg m-3 ppt-2]
  real, dimension(:), intent(inout) :: drho_dS_dT !< Partial derivative of beta with respect to T
                                                  !! [kg m-3 ppt-1 degC-1] or [R ppt-1 degC-1 ~> kg m-3 ppt-1 degC-1]
  real, dimension(:), intent(inout) :: drho_dT_dT !< Partial derivative of alpha with respect to T
                                                  !! [kg m-3 degC-2] or [R degC-2 ~> kg m-3 degC-2]
  real, dimension(:), intent(inout) :: drho_dS_dP !< Partial derivative of beta with respect to pressure
                                                  !! [kg m-3 ppt-1 Pa-1] or [R ppt-1 Pa-1 ~> kg m-3 ppt-1 Pa-1]
  real, dimension(:), intent(inout) :: drho_dT_dP !< Partial derivative of alpha with respect to pressure
                                                  !! [kg m-3 degC-1 Pa-1] or [R degC-1 Pa-1 ~> kg m-3 degC-1 Pa-1]
  integer,            intent(in)  :: start !< Starting index within the array
  integer,            intent(in)  :: npts  !< The number of values to calculate
  type(EOS_type),     pointer     :: EOS   !< Equation of state structure
  real,                  optional, intent(in) :: scale !< A multiplicative factor by which to scale density
                                                  !! in combination with scaling given by US [various]
  ! Local variables
  real, dimension(size(pressure)) :: pres  ! Pressure converted to [Pa]
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  real :: I_p_scale ! The inverse of the factor to convert pressure to units of Pa [R L2 T-2 Pa-1 ~> 1]
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_derivs called with an unassociated EOS_type EOS.")
 
  p_scale = eos%RL2_T2_to_Pa
 
  if (p_scale == 1.0) then
    select case (eos%form_of_EOS)
      case (eos_linear)
        call calculate_density_second_derivs_linear(t, s, pressure, drho_ds_ds, drho_ds_dt, &
                                                    drho_dt_dt, drho_ds_dp, drho_dt_dp, start, npts)
      case (eos_wright)
        call calculate_density_second_derivs_wright(t, s, pressure, drho_ds_ds, drho_ds_dt, &
                                                    drho_dt_dt, drho_ds_dp, drho_dt_dp, start, npts)
      case (eos_teos10)
        call calculate_density_second_derivs_teos10(t, s, pressure, drho_ds_ds, drho_ds_dt, &
                                                    drho_dt_dt, drho_ds_dp, drho_dt_dp, start, npts)
      case default
        call mom_error(fatal, "calculate_density_derivs: EOS%form_of_EOS is not valid.")
    end select
  else
    do j=start,start+npts-1 ; pres(j) = p_scale * pressure(j) ; enddo
    select case (eos%form_of_EOS)
      case (eos_linear)
        call calculate_density_second_derivs_linear(t, s, pres, drho_ds_ds, drho_ds_dt, &
                                                    drho_dt_dt, drho_ds_dp, drho_dt_dp, start, npts)
      case (eos_wright)
        call calculate_density_second_derivs_wright(t, s, pres, drho_ds_ds, drho_ds_dt, &
                                                    drho_dt_dt, drho_ds_dp, drho_dt_dp, start, npts)
      case (eos_teos10)
        call calculate_density_second_derivs_teos10(t, s, pres, drho_ds_ds, drho_ds_dt, &
                                                    drho_dt_dt, drho_ds_dp, drho_dt_dp, start, npts)
      case default
        call mom_error(fatal, "calculate_density_derivs: EOS%form_of_EOS is not valid.")
    end select
  endif
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  if (rho_scale /= 1.0) then ; do j=start,start+npts-1
    drho_ds_ds(j) = rho_scale * drho_ds_ds(j)
    drho_ds_dt(j) = rho_scale * drho_ds_dt(j)
    drho_dt_dt(j) = rho_scale * drho_dt_dt(j)
    drho_ds_dp(j) = rho_scale * drho_ds_dp(j)
    drho_dt_dp(j) = rho_scale * drho_dt_dp(j)
  enddo ; endif
 
  if (p_scale /= 1.0) then
    i_p_scale = 1.0 / p_scale
    do j=start,start+npts-1
      drho_ds_dp(j) = i_p_scale * drho_ds_dp(j)
      drho_dt_dp(j) = i_p_scale * drho_dt_dp(j)
    enddo
  endif
 

calculate_density_second_derivs_scalar()

subroutine mom_eos::calculate_density_second_derivs_scalar ( real, intent(in)  T, real, intent(in)  S, real, intent(in)  pressure, real, intent(out)  drho_dS_dS, real, intent(out)  drho_dS_dT, real, intent(out)  drho_dT_dT, real, intent(out)  drho_dS_dP, real, intent(out)  drho_dT_dP, type(eos_type), pointer  EOS, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate density second derivatives for scalar nputs.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [R L2 T-2 ~> Pa]
[out]	drho_ds_ds	Partial derivative of beta with respect to S [kg m-3 ppt-2] or [R ppt-2 ~> kg m-3 ppt-2]
[out]	drho_ds_dt	Partial derivative of beta with respect to T [kg m-3 ppt-1 degC-1] or [R ppt-1 degC-1 ~> kg m-3 ppt-1 degC-1]
[out]	drho_dt_dt	Partial derivative of alpha with respect to T [kg m-3 degC-2] or [R degC-2 ~> kg m-3 degC-2]
[out]	drho_ds_dp	Partial derivative of beta with respect to pressure [kg m-3 ppt-1 Pa-1] or [R ppt-1 Pa-1 ~> kg m-3 ppt-1 Pa-1]
[out]	drho_dt_dp	Partial derivative of alpha with respect to pressure [kg m-3 degC-1 Pa-1] or [R degC-1 Pa-1 ~> kg m-3 degC-1 Pa-1]
	eos	Equation of state structure
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 928 of file MOM_EOS.F90.

  real, intent(in)  :: T !< Potential temperature referenced to the surface [degC]
  real, intent(in)  :: S !< Salinity [ppt]
  real, intent(in)  :: pressure   !< Pressure [Pa] or [R L2 T-2 ~> Pa]
  real, intent(out) :: drho_dS_dS !< Partial derivative of beta with respect to S
                                  !! [kg m-3 ppt-2] or [R ppt-2 ~> kg m-3 ppt-2]
  real, intent(out) :: drho_dS_dT !< Partial derivative of beta with respect to T
                                  !! [kg m-3 ppt-1 degC-1] or [R ppt-1 degC-1 ~> kg m-3 ppt-1 degC-1]
  real, intent(out) :: drho_dT_dT !< Partial derivative of alpha with respect to T
                                  !! [kg m-3 degC-2] or [R degC-2 ~> kg m-3 degC-2]
  real, intent(out) :: drho_dS_dP !< Partial derivative of beta with respect to pressure
                                  !! [kg m-3 ppt-1 Pa-1] or [R ppt-1 Pa-1 ~> kg m-3 ppt-1 Pa-1]
  real, intent(out) :: drho_dT_dP !< Partial derivative of alpha with respect to pressure
                                  !! [kg m-3 degC-1 Pa-1] or [R degC-1 Pa-1 ~> kg m-3 degC-1 Pa-1]
  type(EOS_type), pointer    :: EOS !< Equation of state structure
  real, optional, intent(in) :: scale !< A multiplicative factor by which to scale density
                                  !! in combination with scaling given by US [various]
  ! Local variables
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  real :: I_p_scale ! The inverse of the factor to convert pressure to units of Pa [R L2 T-2 Pa-1 ~> 1]
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_derivs called with an unassociated EOS_type EOS.")
 
  p_scale = eos%RL2_T2_to_Pa
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_second_derivs_linear(t, s, p_scale*pressure, drho_ds_ds, drho_ds_dt, &
                                                  drho_dt_dt, drho_ds_dp, drho_dt_dp)
    case (eos_wright)
      call calculate_density_second_derivs_wright(t, s, p_scale*pressure, drho_ds_ds, drho_ds_dt, &
                                                  drho_dt_dt, drho_ds_dp, drho_dt_dp)
    case (eos_teos10)
      call calculate_density_second_derivs_teos10(t, s, p_scale*pressure, drho_ds_ds, drho_ds_dt, &
                                                  drho_dt_dt, drho_ds_dp, drho_dt_dp)
    case default
      call mom_error(fatal, "calculate_density_derivs: EOS%form_of_EOS is not valid.")
  end select
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  if (rho_scale /= 1.0) then
    drho_ds_ds = rho_scale * drho_ds_ds
    drho_ds_dt = rho_scale * drho_ds_dt
    drho_dt_dt = rho_scale * drho_dt_dt
    drho_ds_dp = rho_scale * drho_ds_dp
    drho_dt_dp = rho_scale * drho_dt_dp
  endif
 
  if (p_scale /= 1.0) then
    i_p_scale = 1.0 / p_scale
    drho_ds_dp = i_p_scale * drho_ds_dp
    drho_dt_dp = i_p_scale * drho_dt_dp
  endif
 

calculate_spec_vol_array()

subroutine mom_eos::calculate_spec_vol_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  specvol, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS, real, intent(in), optional  spv_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate the specific volume of sea water for 1-D array inputs.

Parameters

[in]	t	potential temperature relative to the surface [degC]
[in]	s	salinity [ppt]
[in]	pressure	pressure [Pa]
[in,out]	specvol	in situ specific volume [kg m-3]
[in]	start	the starting point in the arrays.
[in]	npts	the number of values to calculate.
	eos	Equation of state structure
[in]	spv_ref	A reference specific volume [m3 kg-1]
[in]	scale	A multiplicative factor by which to scale specific volume in combination with scaling given by US [various]

Definition at line 486 of file MOM_EOS.F90.

  real, dimension(:), intent(in)    :: T        !< potential temperature relative to the surface [degC]
  real, dimension(:), intent(in)    :: S        !< salinity [ppt]
  real, dimension(:), intent(in)    :: pressure !< pressure [Pa]
  real, dimension(:), intent(inout) :: specvol  !< in situ specific volume [kg m-3]
  integer,            intent(in)    :: start    !< the starting point in the arrays.
  integer,            intent(in)    :: npts     !< the number of values to calculate.
  type(EOS_type),     pointer       :: EOS      !< Equation of state structure
  real,     optional, intent(in)    :: spv_ref  !< A reference specific volume [m3 kg-1]
  real,     optional, intent(in)    :: scale    !< A multiplicative factor by which to scale specific
                                                !! volume in combination with scaling given by US [various]
 
  real, dimension(size(specvol))  :: rho   ! Density [kg m-3]
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_spec_vol_array called with an unassociated EOS_type EOS.")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_spec_vol_linear(t, s, pressure, specvol, start, npts, &
               eos%rho_T0_S0, eos%drho_dT, eos%drho_dS, spv_ref)
    case (eos_unesco)
      call calculate_spec_vol_unesco(t, s, pressure, specvol, start, npts, spv_ref)
    case (eos_wright)
      call calculate_spec_vol_wright(t, s, pressure, specvol, start, npts, spv_ref)
    case (eos_teos10)
      call calculate_spec_vol_teos10(t, s, pressure, specvol, start, npts, spv_ref)
    case (eos_nemo)
      call calculate_density_nemo(t, s, pressure, rho, start, npts)
      if (present(spv_ref)) then
        specvol(:) = 1.0 / rho(:) - spv_ref
      else
        specvol(:) = 1.0 / rho(:)
      endif
    case default
      call mom_error(fatal, "calculate_spec_vol_array: EOS%form_of_EOS is not valid.")
  end select
 
  if (present(scale)) then ; if (scale /= 1.0) then ; do j=start,start+npts-1
    specvol(j) = scale * specvol(j)
  enddo ; endif ; endif
 

calculate_spec_vol_derivs_array()

subroutine mom_eos::calculate_spec_vol_derivs_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  dSV_dT, real, dimension(:), intent(inout)  dSV_dS, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS  )

private

Calls the appropriate subroutine to calculate specific volume derivatives for an array.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa]
[in,out]	dsv_dt	The partial derivative of specific volume with potential temperature [m3 kg-1 degC-1]
[in,out]	dsv_ds	The partial derivative of specific volume with salinity [m3 kg-1 ppt-1]
[in]	start	Starting index within the array
[in]	npts	The number of values to calculate
	eos	Equation of state structure

Definition at line 988 of file MOM_EOS.F90.

  real, dimension(:), intent(in)  :: T !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)  :: S !< Salinity [ppt]
  real, dimension(:), intent(in)  :: pressure !< Pressure [Pa]
  real, dimension(:), intent(inout) :: dSV_dT !< The partial derivative of specific volume with potential
                                              !! temperature [m3 kg-1 degC-1]
  real, dimension(:), intent(inout) :: dSV_dS !< The partial derivative of specific volume with salinity
                                              !! [m3 kg-1 ppt-1]
  integer,            intent(in)  :: start  !< Starting index within the array
  integer,            intent(in)  :: npts   !< The number of values to calculate
  type(EOS_type),     pointer     :: EOS    !< Equation of state structure
 
  ! Local variables
  real, dimension(size(T)) :: press   ! Pressure converted to [Pa]
  real, dimension(size(T)) :: rho     ! In situ density [kg m-3]
  real, dimension(size(T)) :: dRho_dT ! Derivative of density with temperature [kg m-3 degC-1]
  real, dimension(size(T)) :: dRho_dS ! Derivative of density with salinity [kg m-3 ppt-1]
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_spec_vol_derivs_array called with an unassociated EOS_type EOS.")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_specvol_derivs_linear(t, s, pressure, dsv_dt, dsv_ds, start, &
                                           npts, eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS)
    case (eos_unesco)
      call calculate_density_unesco(t, s, pressure, rho, start, npts)
      call calculate_density_derivs_unesco(t, s, pressure, drho_dt, drho_ds, start, npts)
      do j=start,start+npts-1
        dsv_dt(j) = -drho_dt(j)/(rho(j)**2)
        dsv_ds(j) = -drho_ds(j)/(rho(j)**2)
      enddo
    case (eos_wright)
      call calculate_specvol_derivs_wright(t, s, pressure, dsv_dt, dsv_ds, start, npts)
    case (eos_teos10)
      call calculate_specvol_derivs_teos10(t, s, pressure, dsv_dt, dsv_ds, start, npts)
    case (eos_nemo)
      call calculate_density_nemo(t, s, pressure, rho, start, npts)
      call calculate_density_derivs_nemo(t, s, pressure, drho_dt, drho_ds, start, npts)
      do j=start,start+npts-1
        dsv_dt(j) = -drho_dt(j)/(rho(j)**2)
        dsv_ds(j) = -drho_ds(j)/(rho(j)**2)
      enddo
    case default
      call mom_error(fatal, "calculate_spec_vol_derivs_array: EOS%form_of_EOS is not valid.")
  end select
 

calculate_stanley_density_1d()

subroutine mom_eos::calculate_stanley_density_1d ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(in)  Tvar, real, dimension(:), intent(in)  TScov, real, dimension(:), intent(in)  Svar, real, dimension(:), intent(inout)  rho, type(eos_type), pointer  EOS, integer, dimension(2), intent(in), optional  dom, real, intent(in), optional  rho_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs including the variance of T, S and covariance of T-S, potentially limiting the domain of indices that are worked on. The calculation uses only the second order correction in a series as discussed in Stanley et al., 2020. If rho_ref is present, the anomaly with respect to rho_ref is returned.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [R L2 T-2 ~> Pa]
[in]	tvar	Variance of potential temperature [degC2]
[in]	tscov	Covariance of potential temperature and salinity [degC ppt]
[in]	svar	Variance of salinity [ppt2]
[in,out]	rho	Density (in-situ if pressure is local) [R ~> kg m-3]
	eos	Equation of state structure
[in]	dom	The domain of indices to work on, taking into account that arrays start at 1.
[in]	rho_ref	A reference density [kg m-3]
[in]	scale	A multiplicative factor by which to scale density in combination with scaling given by US [various]

Definition at line 417 of file MOM_EOS.F90.

  real, dimension(:),    intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:),    intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:),    intent(in)    :: pressure !< Pressure [R L2 T-2 ~> Pa]
  real, dimension(:),    intent(in)    :: Tvar     !< Variance of potential temperature [degC2]
  real, dimension(:),    intent(in)    :: TScov    !< Covariance of potential temperature and salinity [degC ppt]
  real, dimension(:),    intent(in)    :: Svar     !< Variance of salinity [ppt2]
  real, dimension(:),    intent(inout) :: rho      !< Density (in-situ if pressure is local) [R ~> kg m-3]
  type(EOS_type),        pointer       :: EOS      !< Equation of state structure
  integer, dimension(2), optional, intent(in) :: dom   !< The domain of indices to work on, taking
                                                       !! into account that arrays start at 1.
  real,                  optional, intent(in) :: rho_ref !< A reference density [kg m-3]
  real,                  optional, intent(in) :: scale !< A multiplicative factor by which to scale density
                                                   !! in combination with scaling given by US [various]
  ! Local variables
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real, dimension(size(rho)) :: pres  ! Pressure converted to [Pa]
  real, dimension(size(T)) :: d2RdTT, d2RdST, d2RdSS, d2RdSp, d2RdTp ! Second derivatives of density wrt T,S,p
  integer :: i, is, ie, npts
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_1d called with an unassociated EOS_type EOS.")
 
  if (present(dom)) then
    is = dom(1) ; ie = dom(2) ; npts = 1 + ie - is
  else
    is = 1 ; ie = size(rho) ; npts = 1 + ie - is
  endif
 
  p_scale = eos%RL2_T2_to_Pa
  do i=is,ie
    pres(i) = p_scale * pressure(i)
  enddo
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_linear(t, s, pres, rho, 1, npts, &
                                    eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS, rho_ref)
      call calculate_density_second_derivs_linear(t, s, pres, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp, 1, npts)
    case (eos_wright)
      call calculate_density_wright(t, s, pres, rho, 1, npts, rho_ref)
      call calculate_density_second_derivs_wright(t, s, pres, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp, 1, npts)
    case (eos_teos10)
      call calculate_density_teos10(t, s, pres, rho, 1, npts, rho_ref)
      call calculate_density_second_derivs_teos10(t, s, pres, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp, 1, npts)
    case default
      call mom_error(fatal, "calculate_stanley_density_scalar: EOS is not valid.")
  end select
 
  ! Equation 25 of Stanley et al., 2020.
  do i=is,ie
    rho(i) = rho(i) &
             + ( 0.5 * d2rdtt(i) * tvar(i) + ( d2rdst(i) * tscov(i) + 0.5 * d2rdss(i) * svar(i) ) )
  enddo
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  if (rho_scale /= 1.0) then ; do i=is,ie
    rho(i) = rho_scale * rho(i)
  enddo ; endif
 

calculate_stanley_density_array()

subroutine mom_eos::calculate_stanley_density_array ( real, dimension(:), intent(in)  T, real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(in)  Tvar, real, dimension(:), intent(in)  TScov, real, dimension(:), intent(in)  Svar, real, dimension(:), intent(inout)  rho, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS, real, intent(in), optional  rho_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate the density of sea water for 1-D array inputs including the variance of T, S and covariance of T-S. The calculation uses only the second order correction in a series as discussed in Stanley et al., 2020. If rho_ref is present, the anomaly with respect to rho_ref is returned.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa]
[in]	tvar	Variance of potential temperature referenced to the surface [degC2]
[in]	tscov	Covariance of potential temperature and salinity [degC ppt]
[in]	svar	Variance of salinity [ppt2]
[in,out]	rho	Density (in-situ if pressure is local) [kg m-3]
[in]	start	Start index for computation
[in]	npts	Number of point to compute
	eos	Equation of state structure
[in]	rho_ref	A reference density [kg m-3].
[in]	scale	A multiplicative factor by which to scale density from kg m-3 to the desired units [R m3 kg-1]

Definition at line 306 of file MOM_EOS.F90.

  real, dimension(:), intent(in)    :: T        !< Potential temperature referenced to the surface [degC]
  real, dimension(:), intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:), intent(in)    :: pressure !< Pressure [Pa]
  real, dimension(:), intent(in)    :: Tvar     !< Variance of potential temperature referenced to the surface [degC2]
  real, dimension(:), intent(in)    :: TScov    !< Covariance of potential temperature and salinity [degC ppt]
  real, dimension(:), intent(in)    :: Svar     !< Variance of salinity [ppt2]
  real, dimension(:), intent(inout) :: rho      !< Density (in-situ if pressure is local) [kg m-3]
  integer,            intent(in)    :: start    !< Start index for computation
  integer,            intent(in)    :: npts     !< Number of point to compute
  type(EOS_type),     pointer       :: EOS      !< Equation of state structure
  real,     optional, intent(in)    :: rho_ref  !< A reference density [kg m-3].
  real,     optional, intent(in)    :: scale    !< A multiplicative factor by which to scale density
                                                !! from kg m-3 to the desired units [R m3 kg-1]
  ! Local variables
  real, dimension(size(T)) :: d2RdTT, d2RdST, d2RdSS, d2RdSp, d2RdTp ! Second derivatives of density wrt T,S,p
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_density_array called with an unassociated EOS_type EOS.")
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_linear(t, s, pressure, rho, start, npts, &
                                    eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS, rho_ref)
      call calculate_density_second_derivs_linear(t, s, pressure, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp, start, npts)
    case (eos_wright)
      call calculate_density_wright(t, s, pressure, rho, start, npts, rho_ref)
      call calculate_density_second_derivs_wright(t, s, pressure, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp, start, npts)
    case (eos_teos10)
      call calculate_density_teos10(t, s, pressure, rho, start, npts, rho_ref)
      call calculate_density_second_derivs_teos10(t, s, pressure, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp, start, npts)
    case default
      call mom_error(fatal, "calculate_stanley_density_array: EOS%form_of_EOS is not valid.")
  end select
 
  ! Equation 25 of Stanley et al., 2020.
  do j=start,start+npts-1
    rho(j) = rho(j) &
             + ( 0.5 * d2rdtt(j) * tvar(j) + ( d2rdst(j) * tscov(j) + 0.5 * d2rdss(j) * svar(j) ) )
  enddo
 
  if (present(scale)) then ; if (scale /= 1.0) then ; do j=start,start+npts-1
    rho(j) = scale * rho(j)
  enddo ; endif ; endif
 

calculate_stanley_density_scalar()

subroutine mom_eos::calculate_stanley_density_scalar ( real, intent(in)  T, real, intent(in)  S, real, intent(in)  pressure, real, intent(in)  Tvar, real, intent(in)  TScov, real, intent(in)  Svar, real, intent(out)  rho, type(eos_type), pointer  EOS, real, intent(in), optional  rho_ref, real, intent(in), optional  scale  )

private

Calls the appropriate subroutine to calculate density of sea water for scalar inputs including the variance of T, S and covariance of T-S. The calculation uses only the second order correction in a series as discussed in Stanley et al., 2020. If rho_ref is present, the anomaly with respect to rho_ref is returned. The density can be rescaled using rho_ref.

Parameters

[in]	t	Potential temperature referenced to the surface [degC]
[in]	s	Salinity [ppt]
[in]	tvar	Variance of potential temperature referenced to the surface [degC2]
[in]	tscov	Covariance of potential temperature and salinity [degC ppt]
[in]	svar	Variance of salinity [ppt2]
[in]	pressure	Pressure [Pa]
[out]	rho	Density (in-situ if pressure is local) [kg m-3] or [R ~> kg m-3]
	eos	Equation of state structure
[in]	rho_ref	A reference density [kg m-3].
[in]	scale	A multiplicative factor by which to scale density from kg m-3 to the desired units [R m3 kg-1]

Definition at line 212 of file MOM_EOS.F90.

  real,           intent(in)  :: T        !< Potential temperature referenced to the surface [degC]
  real,           intent(in)  :: S        !< Salinity [ppt]
  real,           intent(in)  :: Tvar     !< Variance of potential temperature referenced to the surface [degC2]
  real,           intent(in)  :: TScov    !< Covariance of potential temperature and salinity [degC ppt]
  real,           intent(in)  :: Svar     !< Variance of salinity [ppt2]
  real,           intent(in)  :: pressure !< Pressure [Pa]
  real,           intent(out) :: rho      !< Density (in-situ if pressure is local) [kg m-3] or [R ~> kg m-3]
  type(EOS_type), pointer     :: EOS      !< Equation of state structure
  real, optional, intent(in)  :: rho_ref  !< A reference density [kg m-3].
  real, optional, intent(in)  :: scale    !< A multiplicative factor by which to scale density
                                          !! from kg m-3 to the desired units [R m3 kg-1]
  ! Local variables
  real :: d2RdTT, d2RdST, d2RdSS, d2RdSp, d2RdTp ! Second derivatives of density wrt T,S,p
  real :: rho_scale ! A factor to convert density from kg m-3 to the desired units [R m3 kg-1 ~> 1]
  real :: p_scale   ! A factor to convert pressure to units of Pa [Pa T2 R-1 L-2 ~> 1]
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_stanley_density_scalar called with an unassociated EOS_type EOS.")
 
  p_scale = eos%RL2_T2_to_Pa
 
  select case (eos%form_of_EOS)
    case (eos_linear)
      call calculate_density_linear(t, s, p_scale*pressure, rho, &
                                    eos%Rho_T0_S0, eos%dRho_dT, eos%dRho_dS, rho_ref)
      call calculate_density_second_derivs_linear(t, s, pressure, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp)
    case (eos_wright)
      call calculate_density_wright(t, s, p_scale*pressure, rho, rho_ref)
      call calculate_density_second_derivs_wright(t, s, pressure, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp)
    case (eos_teos10)
      call calculate_density_teos10(t, s, p_scale*pressure, rho, rho_ref)
      call calculate_density_second_derivs_teos10(t, s, pressure, d2rdss, d2rdst, &
                                                  d2rdtt, d2rdsp, d2rdtp)
    case default
      call mom_error(fatal, "calculate_stanley_density_scalar: EOS is not valid.")
  end select
 
  ! Equation 25 of Stanley et al., 2020.
  rho = rho + ( 0.5 * d2rdtt * tvar + ( d2rdst * tscov + 0.5 * d2rdss * svar ) )
 
  rho_scale = eos%kg_m3_to_R
  if (present(scale)) rho_scale = rho_scale * scale
  rho = rho_scale * rho
 

calculate_tfreeze_array()

subroutine mom_eos::calculate_tfreeze_array ( real, dimension(:), intent(in)  S, real, dimension(:), intent(in)  pressure, real, dimension(:), intent(inout)  T_fr, integer, intent(in)  start, integer, intent(in)  npts, type(eos_type), pointer  EOS, real, intent(in), optional  pres_scale  )

private

Calls the appropriate subroutine to calculate the freezing point for a 1-D array.

Parameters

[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [other]
[in,out]	t_fr	Freezing point potential temperature referenced to the surface [degC]
[in]	start	Starting index within the array
[in]	npts	The number of values to calculate
	eos	Equation of state structure
[in]	pres_scale	A multiplicative factor to convert pressure into Pa.

Definition at line 656 of file MOM_EOS.F90.

  real, dimension(:), intent(in)    :: S        !< Salinity [ppt]
  real, dimension(:), intent(in)    :: pressure !< Pressure [Pa] or [other]
  real, dimension(:), intent(inout) :: T_fr     !< Freezing point potential temperature referenced
                                                !! to the surface [degC]
  integer,            intent(in)    :: start    !< Starting index within the array
  integer,            intent(in)    :: npts     !< The number of values to calculate
  type(EOS_type),     pointer       :: EOS      !< Equation of state structure
  real,     optional, intent(in)    :: pres_scale !< A multiplicative factor to convert pressure into Pa.
 
  ! Local variables
  real, dimension(size(pressure)) :: pres  ! Pressure converted to [Pa]
  real :: p_scale ! A factor to convert pressure to units of Pa.
  integer :: j
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_TFreeze_scalar called with an unassociated EOS_type EOS.")
 
  p_scale = 1.0 ; if (present(pres_scale)) p_scale = pres_scale
 
  if (p_scale == 1.0) then
    select case (eos%form_of_TFreeze)
      case (tfreeze_linear)
        call calculate_tfreeze_linear(s, pressure, t_fr, start, npts, &
                                      eos%TFr_S0_P0, eos%dTFr_dS, eos%dTFr_dp)
      case (tfreeze_millero)
        call calculate_tfreeze_millero(s, pressure, t_fr, start, npts)
      case (tfreeze_teos10)
        call calculate_tfreeze_teos10(s, pressure, t_fr, start, npts)
      case default
        call mom_error(fatal, "calculate_TFreeze_scalar: form_of_TFreeze is not valid.")
    end select
  else
    do j=start,start+npts-1 ; pres(j) = p_scale * pressure(j) ; enddo
    select case (eos%form_of_TFreeze)
      case (tfreeze_linear)
        call calculate_tfreeze_linear(s, pres, t_fr, start, npts, &
                                      eos%TFr_S0_P0, eos%dTFr_dS, eos%dTFr_dp)
      case (tfreeze_millero)
        call calculate_tfreeze_millero(s, pres, t_fr, start, npts)
      case (tfreeze_teos10)
        call calculate_tfreeze_teos10(s, pres, t_fr, start, npts)
      case default
        call mom_error(fatal, "calculate_TFreeze_scalar: form_of_TFreeze is not valid.")
    end select
  endif
 

calculate_tfreeze_scalar()

subroutine mom_eos::calculate_tfreeze_scalar ( real, intent(in)  S, real, intent(in)  pressure, real, intent(out)  T_fr, type(eos_type), pointer  EOS, real, intent(in), optional  pres_scale  )

private

Calls the appropriate subroutine to calculate the freezing point for scalar inputs.

Parameters

[in]	s	Salinity [ppt]
[in]	pressure	Pressure [Pa] or [other]
[out]	t_fr	Freezing point potential temperature referenced to the surface [degC]
	eos	Equation of state structure
[in]	pres_scale	A multiplicative factor to convert pressure into Pa

Definition at line 625 of file MOM_EOS.F90.

  real,           intent(in)  :: S !< Salinity [ppt]
  real,           intent(in)  :: pressure !< Pressure [Pa] or [other]
  real,           intent(out) :: T_fr !< Freezing point potential temperature referenced
                                      !! to the surface [degC]
  type(EOS_type), pointer     :: EOS !< Equation of state structure
  real, optional, intent(in)  :: pres_scale !< A multiplicative factor to convert pressure into Pa
 
  ! Local variables
  real :: p_scale ! A factor to convert pressure to units of Pa.
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "calculate_TFreeze_scalar called with an unassociated EOS_type EOS.")
 
  p_scale = 1.0 ; if (present(pres_scale)) p_scale = pres_scale
 
  select case (eos%form_of_TFreeze)
    case (tfreeze_linear)
      call calculate_tfreeze_linear(s, p_scale*pressure, t_fr, eos%TFr_S0_P0, &
                                    eos%dTFr_dS, eos%dTFr_dp)
    case (tfreeze_millero)
      call calculate_tfreeze_millero(s, p_scale*pressure, t_fr)
    case (tfreeze_teos10)
      call calculate_tfreeze_teos10(s, p_scale*pressure, t_fr)
    case default
      call mom_error(fatal, "calculate_TFreeze_scalar: form_of_TFreeze is not valid.")
  end select
 

convert_temp_salt_for_teos10()

subroutine, public mom_eos::convert_temp_salt_for_teos10	(	real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed,kd), intent(inout)	T,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed,kd), intent(inout)	S,
		type(hor_index_type), intent(in)	HI,
		integer, intent(in)	kd,
		real, dimension(hi%isd:hi%ied,hi%jsd:hi%jed,kd), intent(in)	mask_z,
		type(eos_type), pointer	EOS
	)

Convert T&S to Absolute Salinity and Conservative Temperature if using TEOS10.

Parameters

[in]	kd	The number of layers to work on
[in]	hi	The horizontal index structure
[in,out]	t	Potential temperature referenced to the surface [degC]
[in,out]	s	Salinity [ppt]
[in]	mask_z	3d mask regulating which points to convert.
	eos	Equation of state structure

Definition at line 1532 of file MOM_EOS.F90.

  integer,               intent(in)    :: kd  !< The number of layers to work on
  type(hor_index_type),  intent(in)    :: HI       !< The horizontal index structure
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed,kd), &
                         intent(inout) :: T   !< Potential temperature referenced to the surface [degC]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed,kd), &
                         intent(inout) :: S   !< Salinity [ppt]
  real, dimension(HI%isd:HI%ied,HI%jsd:HI%jed,kd), &
                         intent(in)    :: mask_z !< 3d mask regulating which points to convert.
  type(EOS_type),        pointer       :: EOS !< Equation of state structure
 
  integer :: i, j, k
  real :: gsw_sr_from_sp, gsw_ct_from_pt, gsw_sa_from_sp
  real :: p
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "convert_temp_salt_to_TEOS10 called with an unassociated EOS_type EOS.")
 
  if ((eos%form_of_EOS /= eos_teos10) .and. (eos%form_of_EOS /= eos_nemo)) return
 
  do k=1,kd ; do j=hi%jsc,hi%jec ; do i=hi%isc,hi%iec
    if (mask_z(i,j,k) >= 1.0) then
     s(i,j,k) = gsw_sr_from_sp(s(i,j,k))
!     Get absolute salinity from practical salinity, converting pressures from Pascal to dbar.
!     If this option is activated, pressure will need to be added as an argument, and it should be
!     moved out into module that is not shared between components, where the ocean_grid can be used.
!     S(i,j,k) = gsw_sa_from_sp(S(i,j,k),pres(i,j,k)*1.0e-4,G%geoLonT(i,j),G%geoLatT(i,j))
     t(i,j,k) = gsw_ct_from_pt(s(i,j,k), t(i,j,k))
    endif
  enddo ; enddo ; enddo

eos_allocate()

subroutine, public mom_eos::eos_allocate

(

type(eos_type), pointer

EOS

)

Allocates EOS_type.

Parameters

eos	Equation of state structure

Definition at line 1491 of file MOM_EOS.F90.

  type(EOS_type), pointer :: EOS !< Equation of state structure
 
  if (.not.associated(eos)) allocate(eos)

eos_domain()

integer function, dimension(2), public mom_eos::eos_domain	(	type(hor_index_type), intent(in)	HI,
		integer, intent(in), optional	halo
	)

This subroutine returns a two point integer array indicating the domain of i-indices to work on in EOS calls based on information from a hor_index type.

Parameters

[in]	hi	The horizontal index structure
[in]	halo	The halo size to work on; missing is equivalent to 0.

Returns

The index domain that the EOS will work on, taking into account that the arrays inside the EOS routines will start at 1.

Definition at line 1163 of file MOM_EOS.F90.

  type(hor_index_type), intent(in)  :: HI    !< The horizontal index structure
  integer,    optional, intent(in)  :: halo  !< The halo size to work on; missing is equivalent to 0.
  integer, dimension(2) :: EOSdom   !< The index domain that the EOS will work on, taking into account
                                    !! that the arrays inside the EOS routines will start at 1.
 
  ! Local variables
  integer :: halo_sz
 
  halo_sz = 0 ; if (present(halo)) halo_sz = halo
 
  eosdom(1) = hi%isc - (hi%isd-1) - halo_sz
  eosdom(2) = hi%iec - (hi%isd-1) + halo_sz
 

eos_end()

subroutine, public mom_eos::eos_end

(

type(eos_type), pointer

EOS

)

Deallocates EOS_type.

Parameters

eos	Equation of state structure

Definition at line 1498 of file MOM_EOS.F90.

  type(EOS_type), pointer :: EOS !< Equation of state structure
 
  if (associated(eos)) deallocate(eos)

eos_init()

subroutine, public mom_eos::eos_init	(	type(param_file_type), intent(in)	param_file,
		type(eos_type), pointer	EOS,
		type(unit_scale_type), intent(in), optional	US
	)

Initializes EOS_type by allocating and reading parameters.

Parameters

[in]	param_file	Parameter file structure
	eos	Equation of state structure
[in]	us	A dimensional unit scaling type

Definition at line 1349 of file MOM_EOS.F90.

  type(param_file_type), intent(in) :: param_file !< Parameter file structure
  type(EOS_type),        pointer    :: EOS !< Equation of state structure
  type(unit_scale_type), intent(in) :: US  !< A dimensional unit scaling type
  optional :: us
  ! Local variables
#include "version_variable.h"
  character(len=40)  :: mdl = "MOM_EOS" ! This module's name.
  character(len=40)  :: tmpstr
 
  if (.not.associated(eos)) call eos_allocate(eos)
 
  ! Read all relevant parameters and write them to the model log.
  call log_version(param_file, mdl, version, "")
 
  call get_param(param_file, mdl, "EQN_OF_STATE", tmpstr, &
                 "EQN_OF_STATE determines which ocean equation of state "//&
                 "should be used.  Currently, the valid choices are "//&
                 '"LINEAR", "UNESCO", "WRIGHT", "NEMO" and "TEOS10". '//&
                 "This is only used if USE_EOS is true.", default=eos_default)
  select case (uppercase(tmpstr))
    case (eos_linear_string)
      eos%form_of_EOS = eos_linear
    case (eos_unesco_string)
      eos%form_of_EOS = eos_unesco
    case (eos_wright_string)
      eos%form_of_EOS = eos_wright
    case (eos_teos10_string)
      eos%form_of_EOS = eos_teos10
    case (eos_nemo_string)
      eos%form_of_EOS = eos_nemo
    case default
      call mom_error(fatal, "interpret_eos_selection: EQN_OF_STATE "//&
                              trim(tmpstr) // "in input file is invalid.")
  end select
  call mom_mesg('interpret_eos_selection: equation of state set to "' // &
                trim(tmpstr)//'"', 5)
 
  if (eos%form_of_EOS == eos_linear) then
    eos%Compressible = .false.
    call get_param(param_file, mdl, "RHO_T0_S0", eos%Rho_T0_S0, &
                 "When EQN_OF_STATE="//trim(eos_linear_string)//", "//&
                 "this is the density at T=0, S=0.", units="kg m-3", &
                 default=1000.0)
    call get_param(param_file, mdl, "DRHO_DT", eos%dRho_dT, &
                 "When EQN_OF_STATE="//trim(eos_linear_string)//", "//&
                 "this is the partial derivative of density with "//&
                 "temperature.", units="kg m-3 K-1", default=-0.2)
    call get_param(param_file, mdl, "DRHO_DS", eos%dRho_dS, &
                 "When EQN_OF_STATE="//trim(eos_linear_string)//", "//&
                 "this is the partial derivative of density with "//&
                 "salinity.", units="kg m-3 PSU-1", default=0.8)
  endif
 
  call get_param(param_file, mdl, "EOS_QUADRATURE", eos%EOS_quadrature, &
                 "If true, always use the generic (quadrature) code "//&
                 "code for the integrals of density.", default=.false.)
 
  call get_param(param_file, mdl, "TFREEZE_FORM", tmpstr, &
                 "TFREEZE_FORM determines which expression should be "//&
                 "used for the freezing point.  Currently, the valid "//&
                 'choices are "LINEAR", "MILLERO_78", "TEOS10"', &
                 default=tfreeze_default)
  select case (uppercase(tmpstr))
    case (tfreeze_linear_string)
      eos%form_of_TFreeze = tfreeze_linear
    case (tfreeze_millero_string)
      eos%form_of_TFreeze = tfreeze_millero
    case (tfreeze_teos10_string)
      eos%form_of_TFreeze = tfreeze_teos10
    case default
      call mom_error(fatal, "interpret_eos_selection:  TFREEZE_FORM "//&
                              trim(tmpstr) // "in input file is invalid.")
  end select
 
  if (eos%form_of_TFreeze == tfreeze_linear) then
    call get_param(param_file, mdl, "TFREEZE_S0_P0",eos%TFr_S0_P0, &
                 "When TFREEZE_FORM="//trim(tfreeze_linear_string)//", "//&
                 "this is the freezing potential temperature at "//&
                 "S=0, P=0.", units="deg C", default=0.0)
    call get_param(param_file, mdl, "DTFREEZE_DS",eos%dTFr_dS, &
                 "When TFREEZE_FORM="//trim(tfreeze_linear_string)//", "//&
                 "this is the derivative of the freezing potential "//&
                 "temperature with salinity.", &
                 units="deg C PSU-1", default=-0.054)
    call get_param(param_file, mdl, "DTFREEZE_DP",eos%dTFr_dP, &
                 "When TFREEZE_FORM="//trim(tfreeze_linear_string)//", "//&
                 "this is the derivative of the freezing potential "//&
                 "temperature with pressure.", &
                 units="deg C Pa-1", default=0.0)
  endif
 
  if ((eos%form_of_EOS == eos_teos10 .OR. eos%form_of_EOS == eos_nemo) .AND. &
      eos%form_of_TFreeze /= tfreeze_teos10) then
      call mom_error(fatal, "interpret_eos_selection:  EOS_TEOS10 or EOS_NEMO \n" //&
      "should only be used along with TFREEZE_FORM = TFREEZE_TEOS10 .")
  endif
 
  ! Unit conversions
  eos%m_to_Z = 1. ; if (present(us)) eos%m_to_Z = us%m_to_Z
  eos%kg_m3_to_R = 1. ; if (present(us)) eos%kg_m3_to_R = us%kg_m3_to_R
  eos%R_to_kg_m3 = 1. ; if (present(us)) eos%R_to_kg_m3 = us%R_to_kg_m3
  eos%RL2_T2_to_Pa = 1. ; if (present(us)) eos%RL2_T2_to_Pa = us%RL2_T2_to_Pa
  eos%L_T_to_m_s = 1. ; if (present(us)) eos%L_T_to_m_s = us%L_T_to_m_s
 

eos_manual_init()

subroutine, public mom_eos::eos_manual_init	(	type(eos_type), pointer	EOS,
		integer, intent(in), optional	form_of_EOS,
		integer, intent(in), optional	form_of_TFreeze,
		logical, intent(in), optional	EOS_quadrature,
		logical, intent(in), optional	Compressible,
		real, intent(in), optional	Rho_T0_S0,
		real, intent(in), optional	drho_dT,
		real, intent(in), optional	dRho_dS,
		real, intent(in), optional	TFr_S0_P0,
		real, intent(in), optional	dTFr_dS,
		real, intent(in), optional	dTFr_dp
	)

Manually initialized an EOS type (intended for unit testing of routines which need a specific EOS)

Parameters

	eos	Equation of state structure
[in]	form_of_eos	A coded integer indicating the equation of state to use.
[in]	form_of_tfreeze	A coded integer indicating the expression for the potential temperature of the freezing point.
[in]	eos_quadrature	If true, always use the generic (quadrature) code for the integrals of density.
[in]	compressible	If true, in situ density is a function of pressure.
[in]	rho_t0_s0	Density at T=0 degC and S=0 ppt [kg m-3]
[in]	drho_dt	Partial derivative of density with temperature in [kg m-3 degC-1]
[in]	drho_ds	Partial derivative of density with salinity in [kg m-3 ppt-1]
[in]	tfr_s0_p0	The freezing potential temperature at S=0, P=0 [degC]
[in]	dtfr_ds	The derivative of freezing point with salinity in [degC ppt-1]
[in]	dtfr_dp	The derivative of freezing point with pressure in [degC Pa-1]

Definition at line 1458 of file MOM_EOS.F90.

  type(EOS_type),    pointer    :: EOS !< Equation of state structure
  integer, optional, intent(in) :: form_of_EOS !< A coded integer indicating the equation of state to use.
  integer, optional, intent(in) :: form_of_TFreeze !< A coded integer indicating the expression for
                                       !! the potential temperature of the freezing point.
  logical, optional, intent(in) :: EOS_quadrature !< If true, always use the generic (quadrature)
                                       !! code for the integrals of density.
  logical, optional, intent(in) :: Compressible  !< If true, in situ density is a function of pressure.
  real   , optional, intent(in) :: Rho_T0_S0 !< Density at T=0 degC and S=0 ppt [kg m-3]
  real   , optional, intent(in) :: drho_dT   !< Partial derivative of density with temperature
                                             !! in [kg m-3 degC-1]
  real   , optional, intent(in) :: dRho_dS   !< Partial derivative of density with salinity
                                             !! in [kg m-3 ppt-1]
  real   , optional, intent(in) :: TFr_S0_P0 !< The freezing potential temperature at S=0, P=0 [degC]
  real   , optional, intent(in) :: dTFr_dS   !< The derivative of freezing point with salinity
                                             !! in [degC ppt-1]
  real   , optional, intent(in) :: dTFr_dp   !< The derivative of freezing point with pressure
                                             !! in [degC Pa-1]
 
  if (present(form_of_eos    ))  eos%form_of_EOS     = form_of_eos
  if (present(form_of_tfreeze))  eos%form_of_TFreeze = form_of_tfreeze
  if (present(eos_quadrature ))  eos%EOS_quadrature  = eos_quadrature
  if (present(compressible   ))  eos%Compressible    = compressible
  if (present(rho_t0_s0      ))  eos%Rho_T0_S0       = rho_t0_s0
  if (present(drho_dt        ))  eos%drho_dT         = drho_dt
  if (present(drho_ds        ))  eos%dRho_dS         = drho_ds
  if (present(tfr_s0_p0      ))  eos%TFr_S0_P0       = tfr_s0_p0
  if (present(dtfr_ds        ))  eos%dTFr_dS         = dtfr_ds
  if (present(dtfr_dp        ))  eos%dTFr_dp         = dtfr_dp
 

eos_quadrature()

logical function, public mom_eos::eos_quadrature

(

type(eos_type), pointer

EOS

)

Return value of EOS_quadrature.

Parameters

eos	Equation of state structure

Definition at line 1565 of file MOM_EOS.F90.

  type(EOS_type),    pointer     :: EOS !< Equation of state structure
 
  eos_quadrature  = eos%EOS_quadrature
 

eos_use_linear()

subroutine, public mom_eos::eos_use_linear	(	real, intent(in)	Rho_T0_S0,
		real, intent(in)	dRho_dT,
		real, intent(in)	dRho_dS,
		type(eos_type), pointer	EOS,
		logical, intent(in), optional	use_quadrature
	)

Set equation of state structure (EOS) to linear with given coefficients.

Note

This routine is primarily for testing and allows a local copy of the EOS_type (EOS argument) to be set to use the linear equation of state independent from the rest of the model.

Parameters

[in]	rho_t0_s0	Density at T=0 degC and S=0 ppt [kg m-3]
[in]	drho_dt	Partial derivative of density with temperature [kg m-3 degC-1]
[in]	drho_ds	Partial derivative of density with salinity [kg m-3 ppt-1]
[in]	use_quadrature	If true, always use the generic (quadrature) code for the integrals of density.
	eos	Equation of state structure

Definition at line 1509 of file MOM_EOS.F90.

  real,              intent(in) :: Rho_T0_S0 !< Density at T=0 degC and S=0 ppt [kg m-3]
  real,              intent(in) :: dRho_dT   !< Partial derivative of density with temperature [kg m-3 degC-1]
  real,              intent(in) :: dRho_dS   !< Partial derivative of density with salinity [kg m-3 ppt-1]
  logical, optional, intent(in) :: use_quadrature !< If true, always use the generic (quadrature)
                                             !! code for the integrals of density.
  type(EOS_type),    pointer    :: EOS       !< Equation of state structure
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "MOM_EOS.F90: EOS_use_linear() called with an unassociated EOS_type EOS.")
 
  eos%form_of_EOS = eos_linear
  eos%Compressible = .false.
  eos%Rho_T0_S0 = rho_t0_s0
  eos%dRho_dT = drho_dt
  eos%dRho_dS = drho_ds
  eos%EOS_quadrature = .false.
  if (present(use_quadrature)) eos%EOS_quadrature = use_quadrature
 

extract_member_eos()

subroutine, public mom_eos::extract_member_eos	(	type(eos_type), pointer	EOS,
		integer, intent(out), optional	form_of_EOS,
		integer, intent(out), optional	form_of_TFreeze,
		logical, intent(out), optional	EOS_quadrature,
		logical, intent(out), optional	Compressible,
		real, intent(out), optional	Rho_T0_S0,
		real, intent(out), optional	drho_dT,
		real, intent(out), optional	dRho_dS,
		real, intent(out), optional	TFr_S0_P0,
		real, intent(out), optional	dTFr_dS,
		real, intent(out), optional	dTFr_dp
	)

Extractor routine for the EOS type if the members need to be accessed outside this module.

Parameters

	eos	Equation of state structure
[out]	form_of_eos	A coded integer indicating the equation of state to use.
[out]	form_of_tfreeze	A coded integer indicating the expression for the potential temperature of the freezing point.
[out]	eos_quadrature	If true, always use the generic (quadrature) code for the integrals of density.
[out]	compressible	If true, in situ density is a function of pressure.
[out]	rho_t0_s0	Density at T=0 degC and S=0 ppt [kg m-3]
[out]	drho_dt	Partial derivative of density with temperature in [kg m-3 degC-1]
[out]	drho_ds	Partial derivative of density with salinity in [kg m-3 ppt-1]
[out]	tfr_s0_p0	The freezing potential temperature at S=0, P=0 [degC]
[out]	dtfr_ds	The derivative of freezing point with salinity [degC PSU-1]
[out]	dtfr_dp	The derivative of freezing point with pressure [degC Pa-1]

Definition at line 1574 of file MOM_EOS.F90.

  type(EOS_type),    pointer     :: EOS !< Equation of state structure
  integer, optional, intent(out) :: form_of_EOS !< A coded integer indicating the equation of state to use.
  integer, optional, intent(out) :: form_of_TFreeze !< A coded integer indicating the expression for
                                       !! the potential temperature of the freezing point.
  logical, optional, intent(out) :: EOS_quadrature !< If true, always use the generic (quadrature)
                                       !! code for the integrals of density.
  logical, optional, intent(out) :: Compressible !< If true, in situ density is a function of pressure.
  real   , optional, intent(out) :: Rho_T0_S0 !< Density at T=0 degC and S=0 ppt [kg m-3]
  real   , optional, intent(out) :: drho_dT   !< Partial derivative of density with temperature
                                              !! in [kg m-3 degC-1]
  real   , optional, intent(out) :: dRho_dS   !< Partial derivative of density with salinity
                                              !! in [kg m-3 ppt-1]
  real   , optional, intent(out) :: TFr_S0_P0 !< The freezing potential temperature at S=0, P=0 [degC]
  real   , optional, intent(out) :: dTFr_dS   !< The derivative of freezing point with salinity
                                              !! [degC PSU-1]
  real   , optional, intent(out) :: dTFr_dp   !< The derivative of freezing point with pressure
                                              !! [degC Pa-1]
 
  if (present(form_of_eos    ))  form_of_eos     = eos%form_of_EOS
  if (present(form_of_tfreeze))  form_of_tfreeze = eos%form_of_TFreeze
  if (present(eos_quadrature ))  eos_quadrature  = eos%EOS_quadrature
  if (present(compressible   ))  compressible    = eos%Compressible
  if (present(rho_t0_s0      ))  rho_t0_s0       = eos%Rho_T0_S0
  if (present(drho_dt        ))  drho_dt         = eos%drho_dT
  if (present(drho_ds        ))  drho_ds         = eos%dRho_dS
  if (present(tfr_s0_p0      ))  tfr_s0_p0       = eos%TFr_S0_P0
  if (present(dtfr_ds        ))  dtfr_ds         = eos%dTFr_dS
  if (present(dtfr_dp        ))  dtfr_dp         = eos%dTFr_dp
 

query_compressible()

logical function, public mom_eos::query_compressible

(

type(eos_type), pointer

EOS

)

Returns true if the equation of state is compressible (i.e. has pressure dependence)

Parameters

eos	Equation of state structure

Definition at line 1339 of file MOM_EOS.F90.

  type(EOS_type), pointer :: EOS !< Equation of state structure
 
  if (.not.associated(eos)) call mom_error(fatal, &
    "query_compressible called with an unassociated EOS_type EOS.")
 
  query_compressible = eos%compressible